Add files using upload-large-folder tool

individual_files/000028__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4

@@ -0,0 +1,224 @@
+#include <core.p4>
+
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_8021Q = 0x8100;
+
+typedef bit<9> egressSpec_t;
+typedef bit<48>  macAddr_t;
+typedef bit<32>  ip4Addr_t;
+
+typedef bit<16> tpid_t;
+
+header ethernet_t{
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+header vlanTag_t{
+    tpid_t tpid;
+
+// Tag protocol identifier
+    bit<1> pcp;
+
+// Priority code point
+    bit<3> dei;
+
+// Drop eligible indicator
+    bit<12> vid;
+
+// VLAN identifier
+}
+
+header ipv4_t{
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct headers{
+    ethernet_t ethernet;
+    vlanTag_t vlanTag;
+    ipv4_t ipv4;
+}
+
+struct metadata{
+    egressSpec_t port;
+}
+
+parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+    state start{
+
+	transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+	pkt.extract(hdr.ethernet);
+	transition select(hdr.ethernet.etherType){
+	    TYPE_8021Q: parse_vlanTag;
+	    TYPE_IPV4: parse_ipv4;
+	    default: accept;
+	}
+    }
+
+    state parse_vlanTag{
+	pkt.extract(hdr.vlanTag);
+	transition accept;
+    }
+
+    state parse_ipv4{
+	pkt.extract(hdr.ipv4);
+	transition accept;
+    }
+}
+
+control myVerifyChecksum(inout headers hdr, inout metadata meta){
+    apply{}
+}
+
+control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+    action drop(){
+	mark_to_drop(stdmeta);
+    }
+
+    action mac_forward(macAddr_t dstAddr, egressSpec_t port){
+	stdmeta.egress_spec = port;
+	meta.port = port;
+	hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+	hdr.ethernet.dstAddr = dstAddr;
+    }
+
+    table vlan_parse_exact{
+	key = {
+	    hdr.ethernet.srcAddr: exact;
+	}
+	actions = {
+	    mac_forward;
+	    drop;
+	    NoAction;
+	}
+	size = 1024;
+	default_action = NoAction();
+    }
+
+
+
+    action add_vlanTag(macAddr_t dstAddr, egressSpec_t port, bit<12> vid){
+	stdmeta.egress_spec = port;
+	hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+	hdr.ethernet.dstAddr = dstAddr;
+	hdr.vlanTag.tpid = TYPE_8021Q;
+	hdr.vlanTag.vid = vid;
+	hdr.vlanTag.setValid();
+	hdr.ethernet.etherType = TYPE_8021Q;
+    }
+
+    table add_vlanTag_exact{
+	key = {
+	    hdr.ethernet.srcAddr: exact;
+	}
+
+	actions = {
+	    add_vlanTag;
+	    drop;
+	    NoAction;
+	}
+	default_action = NoAction();
+    }
+
+    apply{
+	if(hdr.ipv4.isValid() && !hdr.vlanTag.isValid()){
+	    add_vlanTag_exact.apply();
+		
+	}
+	else if(hdr.vlanTag.isValid()){
+	    vlan_parse_exact.apply();
+	}
+    }
+}
+
+
+control cEgress(inout headers hdr,  inout metadata meta, inout standard_metadata_t stdmeta){
+
+    action remove_vlanTag(){
+	hdr.vlanTag.setInvalid();
+	hdr.ethernet.etherType = TYPE_IPV4;
+    }
+
+    action remove(){
+	hdr.vlanTag.setInvalid();
+	hdr.ethernet.etherType = TYPE_IPV4;
+    }
+    
+    table remove_vlanTag_exact{
+	key = {
+	    meta.port: exact;
+	}
+
+	actions = {
+	    remove_vlanTag;
+	    remove;
+	    NoAction;
+	}
+
+	default_action = remove();
+    }
+    apply{
+
+
+	if(hdr.vlanTag.isValid()){
+	    remove_vlanTag_exact.apply();
+	}
+
+    }
+}
+
+
+control myComputeChecksum(inout headers hdr, inout metadata meta){
+    apply{/*
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+	*/
+    }    
+}
+
+control deparserI(packet_out packet, in headers hdr){
+    apply{
+	packet.emit(hdr.ethernet);
+
+	packet.emit(hdr.ipv4);
+    }
+}
+
+V1Switch(
+    parserI(), 
+    myVerifyChecksum(),
+    cIngress(),
+    cEgress(),
+    myComputeChecksum(),
+    deparserI()
+) main;

individual_files/000029__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4

@@ -0,0 +1,232 @@
+#include <core.p4>
+
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<8> TYPE_TCP = 6;
+const bit<8> TYPE_UDP = 17;
+
+
+typedef bit<9> egressSpec_t;
+typedef bit<48>  macAddr_t;
+typedef bit<32>  ip4Addr_t;
+typedef bit<128> ip6Addr_t;
+
+typedef bit<32> packetCounter_t;
+typedef bit<8> port_id_t;
+
+header ethernet_t{
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+header ipv4_t{
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+
+header udp_t{
+    bit<16> source_port;
+    bit<16> destination_port;
+    bit<16> length;
+    bit<16> check_sum;
+}
+
+header tcp_t{
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<4>  res;
+    bit<1>  cwr;
+    bit<1>  ece;
+    bit<1>  urg;
+    bit<1>  ack;
+    bit<1>  psh;
+    bit<1>  rst;
+    bit<1>  syn;
+    bit<1>  fin;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+struct headers{
+    ethernet_t ethernet;
+    ipv4_t ipv4;
+    tcp_t tcp;
+}
+
+struct metadata{
+    bit<16> port;
+}
+
+parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+    state start{
+
+	transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+	pkt.extract(hdr.ethernet);
+	transition select(hdr.ethernet.etherType){
+	    TYPE_IPV4: parse_ipv4;
+	    default: accept;
+	}
+    }
+
+    state parse_ipv4{
+	pkt.extract(hdr.ipv4);
+	transition select(hdr.ipv4.protocol){
+	    TYPE_TCP: parse_transport;
+	    TYPE_UDP: parse_transport;
+	    default: accept;
+	}
+    }
+
+    state parse_transport{
+	pkt.extract(hdr.tcp);
+
+	transition accept;
+    }
+}
+
+control myVerifyChecksum(inout headers hdr, inout metadata meta){
+    apply{}
+}
+
+control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+    
+    counter(64, CounterType.packets) count_parsed;
+    direct_counter(CounterType.packets) count_dropped;
+    
+    action drop(){
+	count_dropped.count();
+
+// counts dropped packets on all ports
+	mark_to_drop(stdmeta);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port){
+	stdmeta.egress_spec = port;
+	hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+	hdr.ethernet.dstAddr = dstAddr;
+	hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+	count_parsed.count((bit<32>) stdmeta.ingress_port);
+
+// counts
+    }
+
+    table ipv4_lpm{
+	key = {
+	    hdr.ipv4.dstAddr: lpm;
+	}
+	actions = {
+	    ipv4_forward;
+	    drop;
+	    NoAction;
+	}
+	size = 1024;
+	default_action = NoAction();
+    }
+
+    table traffic_filter{
+	key = {
+	    hdr.ipv4.dstAddr: ternary;
+
+	}
+	actions = {
+	    ipv4_forward;
+	    drop;
+	}
+	counters = count_dropped;
+	size = 1024;
+	default_action = drop();
+    }
+
+    apply{
+	if(hdr.ipv4.isValid()){
+
+
+	    if(hdr.tcp.isValid()){
+		traffic_filter.apply();
+	    }
+	}
+    }
+}
+
+
+control cEgress(inout headers hdr,  inout metadata meta, inout standard_metadata_t stdmeta){
+    
+    counter(64, CounterType.packets) count_sent;
+
+    action updateCounter(){
+	count_sent.count((bit<32>) stdmeta.egress_spec);
+    }
+    
+    table statistics{
+	key = {
+	    hdr.ipv4.dstAddr: lpm;
+	}
+	actions = {
+	    updateCounter;
+	    NoAction;
+	}
+	size = 1024;
+	default_action = NoAction();
+    }
+    apply{
+	statistics.apply();
+	}
+}
+
+
+control myComputeChecksum(inout headers hdr, inout metadata meta){
+     apply{
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }    
+}
+
+control deparserI(packet_out packet, in headers hdr){
+    apply{
+	packet.emit(hdr.ethernet);
+	packet.emit(hdr.ipv4);
+	packet.emit(hdr.tcp);
+    }
+}
+
+V1Switch(
+    parserI(), 
+    myVerifyChecksum(),
+    cIngress(),
+    cEgress(),
+    myComputeChecksum(),
+    deparserI()
+) main;

individual_files/000032__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4

@@ -0,0 +1,213 @@
+#include <core.p4>
+
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_8021Q = 0x8100;
+
+typedef bit<9> egressSpec_t;
+typedef bit<48>  macAddr_t;
+typedef bit<32>  ip4Addr_t;
+
+typedef bit<16> tpid_t;
+
+header ethernet_t{
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+header vlanTag_t{
+    tpid_t tpid;
+
+// Tag protocol identifier
+    bit<1> pcp;
+
+// Priority code point
+    bit<3> dei;
+
+// Drop eligible indicator
+    bit<12> vid;
+
+// VLAN identifier
+}
+
+header ipv4_t{
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct headers{
+    ethernet_t ethernet;
+    vlanTag_t vlanTag;
+    ipv4_t ipv4;
+}
+
+struct mac_learn_t{
+    bit<48> srcAddr;
+    bit<9> ingress_port;
+    bit<32> srcIpAddr;
+}
+
+struct metadata{
+    egressSpec_t port;
+    mac_learn_t mac_learn_msg;
+}
+
+parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+    state start{
+
+	transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+	pkt.extract(hdr.ethernet);
+	transition select(hdr.ethernet.etherType){
+	    TYPE_IPV4: parse_ipv4;
+	    default: accept;
+	}
+    }
+
+    state parse_ipv4{
+	pkt.extract(hdr.ipv4);
+	meta.mac_learn_msg.srcIpAddr = hdr.ipv4.srcAddr;
+	transition accept;
+    }
+}
+
+control myVerifyChecksum(inout headers hdr, inout metadata meta){
+    apply{}
+}
+
+control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){
+
+    action drop(){
+	mark_to_drop(stdmeta);
+    }
+
+    action unknown_source(){
+	meta.mac_learn_msg.srcAddr = hdr.ethernet.srcAddr;
+	meta.mac_learn_msg.ingress_port = stdmeta.ingress_port;
+
+	digest<mac_learn_t>(0, meta.mac_learn_msg);
+
+// possible error
+    }
+    
+    table learned_MAC{
+	key = {
+	    hdr.ethernet.srcAddr: exact;
+	}
+	actions = {
+	    unknown_source;
+	    NoAction;
+	}
+	default_action = unknown_source();
+    }
+
+    action mac_forward(macAddr_t dstAddr, egressSpec_t port){
+	stdmeta.egress_spec = port;
+
+	hdr.ethernet.dstAddr = dstAddr;
+    }
+
+    table l2_table{
+	key = {
+	    hdr.ipv4.dstAddr: exact;
+	}
+	actions = {
+	    mac_forward;
+	    drop;
+	    NoAction;
+	}
+	size = 1024;
+	default_action = NoAction();
+    }    
+
+    apply{
+	if(hdr.ipv4.isValid()){
+	    learned_MAC.apply();
+	    l2_table.apply();
+	}
+    }
+}
+
+
+control cEgress(inout headers hdr,  inout metadata meta, inout standard_metadata_t stdmeta){
+
+    action remove_vlanTag(){
+	hdr.vlanTag.setInvalid();
+	hdr.ethernet.etherType = TYPE_IPV4;
+    }
+
+    action remove(){
+	hdr.vlanTag.setInvalid();
+	hdr.ethernet.etherType = TYPE_IPV4;
+    }
+    
+    table remove_vlanTag_exact{
+	key = {
+	    meta.port: exact;
+	}
+
+	actions = {
+	    remove_vlanTag;
+	    remove;
+	    NoAction;
+	}
+	default_action = NoAction();
+    }
+    apply{
+
+
+    }
+}
+
+
+control myComputeChecksum(inout headers hdr, inout metadata meta){
+    apply{/*
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+	*/
+    }    
+}
+
+control deparserI(packet_out packet, in headers hdr){
+    apply{
+	packet.emit(hdr.ethernet);
+
+	packet.emit(hdr.ipv4);
+    }
+}
+
+V1Switch(
+    parserI(), 
+    myVerifyChecksum(),
+    cIngress(),
+    cEgress(),
+    myComputeChecksum(),
+    deparserI()
+) main;

individual_files/000033__raw-repositories__0Shark__p4lab.p4

@@ -0,0 +1,414 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_HULA = 0x2345;
+
+#define MAX_HOPS  9
+#define TOR_NUM   32
+#define TOR_NUM_1 33
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+typedef bit<15> qdepth_t;
+typedef bit<32> digest_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header srcRoute_t {
+    bit<1>    bos;
+    bit<15>   port;
+}
+
+header hula_t {
+
+/* 0 is forward path, 1 is the backward path */
+    bit<1>   dir;
+
+/* max qdepth seen so far in the forward path */
+    qdepth_t qdepth;
+
+/* digest of the source routing list to uniquely identify each path */
+    digest_t digest;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header udp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<16> length_;
+    bit<16> checksum;
+}
+
+struct metadata {
+
+    bit<32> index;
+}
+
+struct headers {
+    ethernet_t              ethernet;
+    srcRoute_t[MAX_HOPS]    srcRoutes;
+    ipv4_t                  ipv4;
+    udp_t                   udp;
+    hula_t                  hula;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_HULA : parse_hula;
+            TYPE_IPV4 : parse_ipv4;
+            default   : accept;
+        }
+    }
+
+    state parse_hula {
+        packet.extract(hdr.hula);
+        transition parse_srcRouting;
+    }
+
+    state parse_srcRouting {
+        packet.extract(hdr.srcRoutes.next);
+        transition select(hdr.srcRoutes.last.bos) {
+            1       : parse_ipv4;
+            default : parse_srcRouting;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            8w17: parse_udp;
+            default: accept;
+        }
+    }
+
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;
+    }
+
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {   
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+
+    register<qdepth_t>(TOR_NUM) srcindex_qdepth_reg; 
+
+
+    register<digest_t>(TOR_NUM) srcindex_digest_reg; 
+
+
+/* At each hop, saves the next hop to reach each destination ToR */
+    register<bit<16>>(TOR_NUM) dstindex_nhop_reg; 
+
+
+/* At each hop saves the next hop for each flow */
+    register<bit<16>>(65536) flow_port_reg; 
+
+
+/* This action will drop packets */
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action nop() {
+    }
+
+    action update_ttl(){
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    action set_dmac(macAddr_t dstAddr){
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+    }
+    
+
+/* This action just applies source routing */
+    action srcRoute_nhop() {
+        standard_metadata.egress_spec = (bit<9>)hdr.srcRoutes[0].port;
+        hdr.srcRoutes.pop_front(1);
+    }
+
+
+    action hula_dst(bit<32> index) {
+        meta.index = index;
+    }
+
+
+    action hula_set_nhop(bit<32> index) {
+        dstindex_nhop_reg.write(index, (bit<16>)standard_metadata.ingress_port); 
+    }
+
+
+    action hula_get_nhop(bit<32> index){
+       bit<16> tmp;
+       dstindex_nhop_reg.read(tmp, index); 
+       standard_metadata.egress_spec = (bit<9>)tmp;
+    }
+
+
+/* Record best path at destination ToR */
+    action change_best_path_at_dst(){
+        srcindex_qdepth_reg.write(meta.index, hdr.hula.qdepth);
+        srcindex_digest_reg.write(meta.index, hdr.hula.digest);
+    }
+
+
+    action return_hula_to_src(){
+        hdr.hula.dir = 1;
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+    }
+
+
+    table hula_fwd {
+        key = {
+            hdr.ipv4.dstAddr: exact;
+            hdr.ipv4.srcAddr: exact;
+        }
+        actions = {
+            hula_dst;
+            srcRoute_nhop;
+        }
+        default_action = srcRoute_nhop;
+        size = TOR_NUM_1;
+
+    }
+
+
+    table hula_bwd {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            hula_set_nhop;
+        }
+        size = TOR_NUM;
+    }
+
+
+    table hula_src {
+        key = {
+            hdr.ipv4.srcAddr: exact;
+        }
+        actions = {
+            drop;
+            srcRoute_nhop;
+        }
+        default_action = srcRoute_nhop;
+        size = 2;
+    }
+
+
+/* Get nexthop based on dstAddr using registers */
+    table hula_nhop {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            hula_get_nhop;
+            drop;
+        }
+        default_action = drop;
+        size = TOR_NUM;
+    }
+
+
+/* Set right dmac for packets going to hosts */
+    table dmac {
+        key = {
+            standard_metadata.egress_spec : exact;
+        }
+        actions = {
+            set_dmac;
+            nop;
+        }
+        default_action = nop;
+        size = 16;
+    }
+
+    apply {
+        if (hdr.hula.isValid()){
+            if (hdr.hula.dir == 0){
+                switch(hula_fwd.apply().action_run){
+
+
+                    hula_dst: {
+
+
+/* if it is the destination ToR compare qdepth */
+                        qdepth_t old_qdepth;
+                        srcindex_qdepth_reg.read(old_qdepth, meta.index);
+
+                        if (old_qdepth > hdr.hula.qdepth){
+                            change_best_path_at_dst();
+
+
+/* only return hula packets that update best path */
+                            return_hula_to_src();
+                        }else{
+
+
+                            digest_t old_digest;
+                            srcindex_digest_reg.read(old_digest, meta.index);
+                            if (old_digest == hdr.hula.digest){
+                                srcindex_qdepth_reg.write(meta.index, hdr.hula.qdepth);
+                            }
+
+                            drop();
+                        } 
+                    }
+                }
+            }else {
+
+/* update routing table in reverse path */
+                hula_bwd.apply();
+
+
+/* drop if source ToR */
+                hula_src.apply();
+            }
+        } else if (hdr.ipv4.isValid()){
+            bit<32> flow_hash;
+            hash(
+                flow_hash, 
+                HashAlgorithm.crc16,
+                32w0, 
+                { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.srcPort}, 
+                32w65536
+            );
+
+            bit<16> port;
+            flow_port_reg.read(port, flow_hash);
+
+            if (port == 0) {
+
+// next hop for destination ToR
+                hula_nhop.apply();
+                bit<16> next_hop = (bit<16>)standard_metadata.egress_spec;
+                flow_port_reg.write(flow_hash, next_hop);
+            } else {
+                standard_metadata.egress_spec = (bit<9>)port;
+            }
+
+
+/* set the right dmac so that ping and iperf work */
+            dmac.apply();
+        }else {
+            drop();
+        }
+
+        if (hdr.ipv4.isValid()){
+            update_ttl();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {
+
+//hula header is valid and forward path
+        if (hdr.hula.isValid() && hdr.hula.dir == 0) {
+
+// hula qdepth greater than curr queue depth
+            if (hdr.hula.qdepth < (qdepth_t)standard_metadata.deq_qdepth) {
+                hdr.hula.qdepth = (qdepth_t)standard_metadata.deq_qdepth;
+            }
+        }
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.hula);
+        packet.emit(hdr.srcRoutes);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.udp);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000034__raw-repositories__0Shark__p4lab.p4

@@ -0,0 +1,214 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+header ipv4_t {
+    bit<4>  version;
+    bit<4>  ihl;
+    bit<8>  diffserv;
+    bit<16> totalLen;
+    bit<16> identification;
+    bit<3>  flags;
+    bit<13> fragOffset;
+    bit<8>  ttl;
+    bit<8>  protocol;
+    bit<16> hdrChecksum;
+    bit<32> srcAddr;
+    bit<32> dstAddr;
+}
+
+header tcp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<3>  res;
+    bit<3>  ecn;
+    bit<6>  ctrl;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+struct metadata {
+    bit<14> ecmp_select;
+}
+
+struct headers {
+    ethernet_t ethernet;
+    ipv4_t     ipv4;
+    tcp_t      tcp;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+    state start {
+        transition parse_ethernet;
+    }
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            0x800: parse_ipv4;
+            default: accept;
+        }
+    }
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            6: parse_tcp;
+            default: accept;
+        }
+    }
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        transition accept;
+    }
+}
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    bit<14> flow_hash;
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+    action set_ecmp_select(bit<16> ecmp_base, bit<32> ecmp_count) {
+        hash(
+            flow_hash, 
+            HashAlgorithm.crc16,
+            ecmp_base,
+            { hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr,
+              hdr.ipv4.protocol,
+              hdr.tcp.srcPort,
+              hdr.tcp.dstPort },
+            ecmp_count
+        );
+
+        meta.ecmp_select = flow_hash;
+    }
+    action set_nhop(bit<48> nhop_dmac, bit<32> nhop_ipv4, bit<9> port) {
+        hdr.ethernet.dstAddr = nhop_dmac;
+        hdr.ipv4.dstAddr = nhop_ipv4;
+        standard_metadata.egress_spec = port;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+    table ecmp_group {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            drop;
+            set_ecmp_select;
+        }
+        size = 1024;
+    }
+    table ecmp_nhop {
+        key = {
+            meta.ecmp_select: exact;
+        }
+        actions = {
+            drop;
+            set_nhop;
+        }
+        size = 2;
+    }
+    apply {
+
+        if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) {
+            ecmp_group.apply();
+            ecmp_nhop.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+
+    action rewrite_mac(bit<48> smac) {
+        hdr.ethernet.srcAddr = smac;
+    }
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+    table send_frame {
+        key = {
+            standard_metadata.egress_port: exact;
+        }
+        actions = {
+            rewrite_mac;
+            drop;
+        }
+        size = 256;
+    }
+    apply {
+        send_frame.apply();
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.tcp);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000035__raw-repositories__0Shark__p4lab.p4

@@ -0,0 +1,184 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+
+
+/* IP protocols */
+const bit<8> IP_PROTOCOLS_ICMP       =   1;
+const bit<8> IP_PROTOCOLS_IGMP       =   2;
+const bit<8> IP_PROTOCOLS_IPV4       =   4;
+const bit<8> IP_PROTOCOLS_TCP        =   6;
+const bit<8> IP_PROTOCOLS_UDP        =  17;
+const bit<8> IP_PROTOCOLS_IPV6       =  41;
+const bit<8> IP_PROTOCOLS_GRE        =  47;
+const bit<8> IP_PROTOCOLS_IPSEC_ESP  =  50;
+const bit<8> IP_PROTOCOLS_IPSEC_AH   =  51;
+const bit<8> IP_PROTOCOLS_ICMPV6     =  58;
+const bit<8> IP_PROTOCOLS_EIGRP      =  88;
+const bit<8> IP_PROTOCOLS_OSPF       =  89;
+const bit<8> IP_PROTOCOLS_PIM        = 103;
+const bit<8> IP_PROTOCOLS_VRRP       = 112;
+
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    tos;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+
+struct metadata {
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+
+
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+
+    apply {
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.tos,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000036__raw-repositories__0Shark__p4lab.p4

@@ -0,0 +1,158 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_SRCROUTING = 0x1234;
+
+#define MAX_HOPS 9
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header srcRoute_t {
+    bit<1>    bos;
+    bit<15>   port;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t              ethernet;
+    srcRoute_t[MAX_HOPS]    srcRoutes;
+    ipv4_t                  ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+
+        transition accept;
+    }
+
+    state parse_srcRouting {
+
+        transition accept;
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action srcRoute_nhop() {
+
+    }
+
+    action srcRoute_finish() {
+        hdr.ethernet.etherType = TYPE_IPV4;
+    }
+
+    action update_ttl(){
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    apply {
+        if (hdr.srcRoutes[0].isValid()){
+
+
+            if (hdr.ipv4.isValid()){
+                update_ttl();
+            }
+        }else{
+            drop();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.srcRoutes);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000037__raw-repositories__ana13zs__p4tutorials.p4

@@ -0,0 +1,144 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+    apply {
+
+        ipv4_lpm.apply();
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000038__raw-repositories__ana13zs__p4tutorials.p4

@@ -0,0 +1,183 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+// NOTE: new type added here
+const bit<16> TYPE_MYTUNNEL = 0x1212;
+const bit<16> TYPE_IPV4 = 0x800;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+
+// NOTE: added new header type
+header myTunnel_t {
+    bit<16> proto_id;
+    bit<16> dst_id;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+
+// NOTE: Added new header type to headers struct
+struct headers {
+    ethernet_t   ethernet;
+    myTunnel_t   myTunnel;
+    ipv4_t       ipv4;
+}
+
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4 : parse_ipv4;
+            default : accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+
+}
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = drop();
+    }
+
+
+
+
+
+
+
+    apply {
+
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000039__raw-repositories__ana13zs__p4tutorials.p4

@@ -0,0 +1,163 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<8>  TCP_PROTOCOL = 0x06;
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<19> ECN_THRESHOLD = 10;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    tos;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct metadata {
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                  out headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+        }
+        size = 1024;
+        default_action = drop;
+    }
+
+    apply {
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {
+
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.tos,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000040__raw-repositories__ana13zs__p4tutorials.p4

@@ -0,0 +1,232 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<8>  UDP_PROTOCOL = 0x11;
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<5>  IPV4_OPTION_MRI = 31;
+
+#define MAX_HOPS 9
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+typedef bit<32> switchID_t;
+typedef bit<32> qdepth_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header ipv4_option_t {
+    bit<1> copyFlag;
+    bit<2> optClass;
+    bit<5> option;
+    bit<8> optionLength;
+}
+
+header mri_t {
+    bit<16>  count;
+}
+
+header switch_t {
+    switchID_t  swid;
+    qdepth_t    qdepth;
+}
+
+struct ingress_metadata_t {
+    bit<16>  count;
+}
+
+struct parser_metadata_t {
+    bit<16>  remaining;
+}
+
+struct metadata {
+    ingress_metadata_t   ingress_metadata;
+    parser_metadata_t   parser_metadata;
+}
+
+struct headers {
+    ethernet_t         ethernet;
+    ipv4_t             ipv4;
+    ipv4_option_t      ipv4_option;
+    mri_t              mri;
+    switch_t[MAX_HOPS] swtraces;
+}
+
+error { IPHeaderTooShort }
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        verify(hdr.ipv4.ihl >= 5, error.IPHeaderTooShort);
+        transition select(hdr.ipv4.ihl) {
+            5             : accept;
+            default       : parse_ipv4_option;
+        }
+    }
+
+    state parse_ipv4_option {
+
+        transition accept;
+    }
+
+    state parse_mri {
+
+        transition accept;
+    }
+
+    state parse_swtrace {
+
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+    apply {
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    action add_swtrace(switchID_t swid) {
+
+    }
+
+    table swtrace {
+        actions        = {
+            add_swtrace;
+            NoAction;
+        }
+
+        default_action =  NoAction();
+    }
+
+    apply {
+
+        swtrace.apply();
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000041__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4

@@ -0,0 +1,279 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+const bit<16> TYPE_IPV4 = 0x800;
+typedef bit<10> PortId_t;
+const PortId_t NUM_PORTS = 512;
+#define PACKET_COUNT_WIDTH 32
+#define TRESHOLD 200
+#define BYTE_COUNT_WIDTH 48
+
+#define PACKET_BYTE_COUNT_WIDTH 80
+
+#define PACKET_COUNT_RANGE (PACKET_BYTE_COUNT_WIDTH-1):BYTE_COUNT_WIDTH
+#define BYTE_COUNT_RANGE (BYTE_COUNT_WIDTH-1):0
+
+#define FLOW_TABLE_SIZE_EACH 1024
+#define HASH_BASE 10w0
+#define HASH_MAX 10w1023
+typedef bit<PACKET_BYTE_COUNT_WIDTH> PacketByteCountState_t;
+
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+struct ingress_metadata_t {
+
+    bit<64> my_flowID;
+    bit<64> my_estimated_count;
+    bit<1> already_matched;
+    bit<32> nhop_ipv4;
+    bit<64> carry_min;
+    bit<64> carry_min_plus_one;
+    bit<8> min_stage;
+    bit<1> do_recirculate;
+    bit<9> orig_egr_port;
+
+    bit<32> hashed_flow;
+    bit<32> hashed_flow_opposite;
+    bit<32> hashed_address_s3;
+
+    bit<64> random_bits;
+    bit<12> random_bits_short;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+    ip4Addr_t realsrcAddr;
+    ip4Addr_t realdstAddr;
+}
+
+struct metadata {
+    @name("ingress_metadata")
+    ingress_metadata_t   ingress_metadata;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+}
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+    direct_counter(CounterType.packets) c;
+    register<bit<48>>(1024) last_seen;
+
+    register<bit<64>>(1024) flows;
+
+    action get_inter_packet_gap(out bit<48> interval,bit<32> flow_id)
+
+    {
+      bit<48> last_pkt_cnt;
+      bit<32> index;
+
+/* Get the time the previous packet was seen */
+      last_seen.read(last_pkt_cnt,flow_id);
+      interval = last_pkt_cnt + 1;
+
+/* Update the register with the new timestamp */
+      last_seen.write((bit<32>)flow_id,
+      interval);
+    }
+    action compute_flow_id () {
+
+// combines the source and destination IP addresses to create a unique flow ID for each flow
+      meta.ingress_metadata.my_flowID[31:0]=hdr.ipv4.srcAddr;
+      meta.ingress_metadata.my_flowID[63:32]=hdr.ipv4.dstAddr;
+    }
+    action compute_reg_index () {
+
+        hash(meta.ingress_metadata.hashed_flow, HashAlgorithm.crc16, HASH_BASE,
+            {hdr.ipv4.srcAddr, 7w11, hdr.ipv4.dstAddr}, HASH_MAX);
+        hash(meta.ingress_metadata.hashed_flow_opposite, HashAlgorithm.crc16, HASH_BASE,
+            {hdr.ipv4.dstAddr, 7w11, hdr.ipv4.srcAddr}, HASH_MAX);
+      }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+    action update_origin(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        counters = c;
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+    apply {
+        if (hdr.ipv4.isValid()) {
+
+// if the packet is an IPv4 packet
+            ipv4_lpm.apply();
+
+// apply the LPM table for routing
+            bit<48> tmp;
+            bit<32> flow;
+            bit<32> flow_opp;
+            compute_reg_index();
+
+// compute the register index for the flow
+            bit<48> last_pkt_cnt;
+            bit<48> last_pkt_cnt_opp;
+
+/* Get the time the previous packet was seen */
+            flow = meta.ingress_metadata.hashed_flow;
+
+// get the flow ID
+            flow_opp = meta.ingress_metadata.hashed_flow_opposite;
+
+// get the opposite flow ID
+            last_seen.read(last_pkt_cnt,flow);
+
+// read the last packet count of the flow
+            last_seen.read(last_pkt_cnt_opp,flow_opp);
+
+// read the last packet count of the opposite flow
+            tmp = last_pkt_cnt - last_pkt_cnt_opp + 1;
+
+// calculate the inter-packet gap
+            if(tmp < TRESHOLD) {
+
+// if the inter-packet gap is less than the threshold
+
+              get_inter_packet_gap(last_pkt_cnt,flow);
+
+// it updates the inter-packet gap
+            }
+            else{
+              drop();
+            }
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      	  hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000042__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4

@@ -0,0 +1,292 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+const bit<16> TYPE_IPV4 = 0x800;
+typedef bit<10> PortId_t;
+const PortId_t NUM_PORTS = 512;
+#define PACKET_COUNT_WIDTH 32
+#define TRESHOLD 200
+
+//microseconds
+#define WINDOW 15000000
+
+// 15 seconds, time window for resetting asymmetric flow detection
+#define BYTE_COUNT_WIDTH 48
+
+#define PACKET_BYTE_COUNT_WIDTH 80
+
+#define PACKET_COUNT_RANGE (PACKET_BYTE_COUNT_WIDTH-1):BYTE_COUNT_WIDTH
+#define BYTE_COUNT_RANGE (BYTE_COUNT_WIDTH-1):0
+
+#define FLOW_TABLE_SIZE_EACH 1024
+#define HASH_BASE 10w0
+#define HASH_MAX 10w1023
+typedef bit<PACKET_BYTE_COUNT_WIDTH> PacketByteCountState_t;
+
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+struct ingress_metadata_t {
+
+    bit<64> my_flowID;
+    bit<64> my_estimated_count;
+    bit<1> already_matched;
+    bit<32> nhop_ipv4;
+    bit<64> carry_min;
+    bit<64> carry_min_plus_one;
+    bit<8> min_stage;
+    bit<1> do_recirculate;
+    bit<9> orig_egr_port;
+
+
+    bit<32> hashed_flow;
+    bit<32> hashed_flow_opposite;
+    bit<32> hashed_address_s3;
+
+    bit<64> random_bits;
+    bit<12> random_bits_short;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+    ip4Addr_t realsrcAddr;
+    ip4Addr_t realdstAddr;
+}
+
+struct metadata {
+    @name("ingress_metadata")
+    ingress_metadata_t   ingress_metadata;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+}
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+    direct_counter(CounterType.packets) c;
+    register<bit<48>>(1024) last_seen;
+    register<bit<48>>(1024) window;
+
+    action get_inter_packet_gap(out bit<48> interval,bit<32> flow_id)
+
+    {
+      bit<48> last_pkt_cnt;
+      bit<32> index;
+
+/* Get the time the previous packet was seen */
+      last_seen.read(last_pkt_cnt,flow_id);
+      interval = last_pkt_cnt + 1;
+
+/* Update the register with the new timestamp */
+      last_seen.write((bit<32>)flow_id,
+      interval);
+    }
+
+    action restore_flow(bit<32> flow,bit<32> flow_opp)
+
+// resets the flow and the opposite registers
+    {
+
+      last_seen.write((bit<32>)flow,0);
+      last_seen.write((bit<32>)flow_opp,0);
+    }
+
+    action compute_reg_index () {
+
+        hash(meta.ingress_metadata.hashed_flow, HashAlgorithm.crc16, HASH_BASE,
+            {hdr.ipv4.srcAddr, 7w11, hdr.ipv4.dstAddr}, HASH_MAX);
+        hash(meta.ingress_metadata.hashed_flow_opposite, HashAlgorithm.crc16, HASH_BASE,
+            {hdr.ipv4.dstAddr, 7w11, hdr.ipv4.srcAddr}, HASH_MAX);
+      }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        counters = c;
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+    apply {
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+            bit<48> tmp;
+	    bit<48> time;
+            bit<32> flow;
+            bit<32> flow_opp;
+            compute_reg_index();
+            bit<48> last_pkt_cnt;
+            bit<48> last_pkt_cnt_opp;
+
+	    bit<48> last_time;
+	    bit<48> intertime;
+
+/* Get the time the previous packet was seen */
+            flow = meta.ingress_metadata.hashed_flow;
+            flow_opp = meta.ingress_metadata.hashed_flow_opposite;
+
+	    window.read(last_time,flow);
+
+
+// first time initialize
+	    if(last_time == (bit<48>)0){
+	    	window.write((bit<32>)flow,standard_metadata.ingress_global_timestamp);
+
+// write the first packet
+	    }
+
+	    intertime = standard_metadata.ingress_global_timestamp - last_time;
+
+// intertime is the time difference between the last packet and the current packet
+        window.write((bit<32>)flow,standard_metadata.ingress_global_timestamp);
+
+// check window
+	    if(intertime > WINDOW){
+
+// if the time difference is greater than the window, reset the flow
+		restore_flow(flow,flow_opp);
+	    }
+	    else{
+
+	    }
+
+            last_seen.read(last_pkt_cnt,flow);
+            last_seen.read(last_pkt_cnt_opp,flow_opp);
+            tmp = last_pkt_cnt - last_pkt_cnt_opp + 1;
+
+            if(tmp < TRESHOLD) {
+              get_inter_packet_gap(last_pkt_cnt,flow);
+            }
+            else{
+              drop();
+            }
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      	  hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000043__raw-repositories__ByungUkMin__p4-encryption.p4

@@ -0,0 +1,164 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define MCAST_ID 1
+#define CPU_PORT 255
+
+
+typedef bit<48> macAddr_t;
+
+
+/**/
+/*  Headers  */
+/**/
+
+@controller_header("packet_in")
+header packet_in_header_t {
+    bit<9> ingress_port;
+    bit<7> _pad;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t ethernet;
+    packet_in_header_t packet_in;
+}
+
+
+/**/
+/*  Parser  */
+/**/
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition accept;
+    }
+}
+
+
+/**/
+/*  Checksum Verification  */
+/**/
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+/**/
+/*  Ingress Processing  */
+/**/
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action flood() {
+        standard_metadata.mcast_grp = MCAST_ID;
+    }
+
+    table bridge_table {
+        key = {
+            hdr.ethernet.dstAddr: exact;
+            standard_metadata.ingress_port: exact;
+        }
+        actions = {
+            drop;
+            flood;
+        }
+        size = 1024;
+        default_action = flood;
+    }
+    
+    apply {
+        bridge_table.apply();
+    }
+}
+
+
+/**/
+/*  Egress Processing  */
+/**/
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action to_controller() {
+        hdr.packet_in.setValid();
+        hdr.packet_in.ingress_port = standard_metadata.ingress_port;
+    }
+
+    apply {
+
+// Prune multicast packets going to ingress port to prevent loops
+        if (standard_metadata.egress_port == standard_metadata.ingress_port)
+            drop();
+
+
+// Send a copy of the packet to the controller for learning
+        if (standard_metadata.egress_port == CPU_PORT)
+            to_controller();
+    }
+}
+
+
+/**/
+/*  Checksum Computation  */
+/**/
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+/**/
+/*  Deparser  */
+/**/
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.packet_in);
+        packet.emit(hdr.ethernet);
+    }
+}
+
+
+/**/
+/*  Bridge  */
+/**/
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000044__raw-repositories__ByungUkMin__p4-encryption.p4

@@ -0,0 +1,287 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define MCAST_ID 1
+#define CPU_PORT 255
+
+
+#define ETH_TYPE_ARP 0x0806
+#define ETH_TYPE_VLAN 0x8100
+
+typedef bit<9> egressSpec_t;
+typedef bit<48> macAddr_t;
+
+
+/**/
+/*  Headers  */
+/**/
+
+@controller_header("packet_in")
+header packet_in_header_t {
+    bit<9> ingress_port;
+    bit<7> _pad;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+header vlan_t {
+    bit<3> pcp;
+    bit<1> cfi;
+    bit<12> vid;
+    bit<16> etherType;
+}
+
+struct metadata {
+    bit<12> vid;
+    bit<16> etherType;
+    bit<4> _pad;
+}
+
+struct headers {
+    vlan_t vlan;
+    ethernet_t ethernet;
+    packet_in_header_t packet_in;
+}
+
+
+/**/
+/*  Parser  */
+/**/
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        meta.vid = 0;
+        meta.etherType = hdr.ethernet.etherType;
+        transition select(hdr.ethernet.etherType) {
+            ETH_TYPE_VLAN: parse_vlan;
+            default: accept;
+        }
+    }
+
+    state parse_vlan {
+        packet.extract(hdr.vlan);
+        meta.vid = hdr.vlan.vid;
+        meta.etherType = hdr.vlan.etherType;
+        transition accept;
+    }
+}
+
+
+/**/
+/*  Checksum Verification  */
+/**/
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+/**/
+/*  Ingress Processing  */
+/**/
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action forward(egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+    }
+
+    action flood() {
+        standard_metadata.mcast_grp = MCAST_ID;
+    }
+
+/**/
+/* Switch Table Logic - Begins */
+/**/
+    
+
+    
+    table switch_table {
+        key = {
+            hdr.ethernet.dstAddr: exact;
+	    meta.vid: exact;
+
+        }
+        actions = {
+            flood;
+            forward;
+        }
+        size = 1024;
+        default_action = flood;
+    }
+
+
+/**/
+/* Switch Table Logic - Ends */
+/**/
+
+    apply {
+
+/**/
+/* Ingress Apply Logic - Begins */
+/**/
+
+
+
+	if (hdr.ethernet.etherType == ETH_TYPE_VLAN) {
+
+// VLAN-enabled
+	    if (meta.etherType == ETH_TYPE_ARP) {
+
+// VLAN-enabled + ARP packet
+	        flood();
+	    }
+	    else {
+
+// VLAN-enabled + Non-ARP packet
+	        switch_table.apply();
+	    }
+	}
+	else if (hdr.ethernet.etherType == ETH_TYPE_ARP) {
+
+// Non-VLAN + ARP packet
+	    flood();
+	}
+	else {
+
+// Non-VLAN + Non-ARP packet
+	    switch_table.apply();
+	}
+
+
+/**/
+/* Ingress Apply Logic - Ends */
+/**/
+    }
+}
+
+
+/**/
+/*  Egress Processing  */
+/**/
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    action noop() {
+
+/* empty */
+    }
+    
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action to_controller() {
+        hdr.packet_in.setValid();
+        hdr.packet_in.ingress_port = standard_metadata.ingress_port;
+    }
+
+
+/**/
+/* VLAN Table Logic - Begins */
+/**/
+    
+
+    
+    table vlan_table {
+        key = {
+
+	    meta.vid: exact;
+            standard_metadata.egress_port: exact;
+        }
+        actions = {
+            noop;
+            drop;
+        }
+        size = 1024;
+        default_action = drop;
+    }
+
+
+/**/
+/* Switch Table Logic - Ends */
+/**/
+
+    apply {
+
+/**/
+/* Egress Apply Logic - Begins */
+/**/
+
+
+
+
+// (1) Prune multicast packets going to ingress port to prevent loops
+        if (standard_metadata.egress_port == standard_metadata.ingress_port)
+            drop();
+
+
+
+// (2) Send a copy of the packet to the controller for learning
+        if (standard_metadata.egress_port == CPU_PORT)
+            to_controller();
+
+
+// (3) Check if the VLAN header exists. If yes, then drop packets ...
+	if (hdr.ethernet.etherType == ETH_TYPE_VLAN) {
+	    vlan_table.apply();
+	}
+
+
+/**/
+/* Egress Apply Logic - Ends */
+/**/
+    }
+}
+
+
+/**/
+/*  Checksum Computation  */
+/**/
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+/**/
+/*  Deparser  */
+/**/
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.packet_in);
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.vlan);
+    }
+}
+
+
+/**/
+/*  Switch  */
+/**/
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000045__raw-repositories__cpt-harlock__p4-cuckoo-hash.p4

@@ -0,0 +1,198 @@
+#include <v1model.p4>
+#include <core.p4>
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+
+#define CH_LENGTH 512
+#define CH_LENGTH_BIT 16w512
+
+// 106 bits per register, first 96 bits for key and others for value
+register<bit<106>>(CH_LENGTH) ch_first_row;
+register<bit<106>>(CH_LENGTH) ch_second_row;
+register<bit<10>>(1) counter_reg;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header tcp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<3>  res;
+    bit<3>  ecn;
+    bit<6>  ctrl;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+    tcp_t	 tcp;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet { 
+		packet.extract(hdr.ethernet);
+		transition select(hdr.ethernet.etherType) {
+			0x0800: parse_ip;
+			default: reject;
+		}
+    }
+
+	state parse_ip {
+		packet.extract(hdr.ipv4);
+		transition select(hdr.ipv4.protocol) {
+			0x6: parse_tcp;
+			default: reject;
+		}
+	}
+
+	state parse_tcp {
+		packet.extract(hdr.tcp);
+		transition accept;
+	}
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+
+
+
+
+
+
+
+
+//compute CH indices
+    apply {
+	bit<32> first_index;
+	bit<32> second_index;
+	bit<96> packet_key = hdr.ipv4.srcAddr ++ hdr.ipv4.dstAddr ++ hdr.tcp.srcPort ++ hdr.tcp.dstPort;
+	hash(first_index, HashAlgorithm.crc16, 16w0, { 0w0, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.srcPort, hdr.tcp.dstPort }, 16w512);
+	hash(second_index, HashAlgorithm.crc16, 16w0, { 1w0, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.srcPort, hdr.tcp.dstPort }, 16w512);
+	bit<106> first_result;
+	bit<106> second_result;
+	bit<10> counter_result;
+	ch_first_row.read(first_result, first_index);
+	ch_second_row.read(second_result, second_index);
+	if (first_result[95:0] == packet_key) {
+
+//do nothing
+	} else if (second_result[95:0] == packet_key) {
+
+//do nothing
+	} else if (first_result[95:0] == 96w0) {
+		counter_reg.read(counter_result, 0);
+		ch_first_row.write(first_index, counter_result ++ packet_key);
+		counter_reg.write(0, counter_result+1);
+	} else if (second_result[95:0] == 96w0) {
+		counter_reg.read(counter_result, 0);
+		ch_second_row.write(second_index, counter_result ++ packet_key);
+		counter_reg.write(0, counter_result+1);
+	} 
+
+
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000046__raw-repositories__bennyrubin__HydraCode.p4

@@ -0,0 +1,406 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#include <v1model.p4>
+
+#define ETHERTYPE_CHECKER 0x5678;
+
+header eth_type2_t {
+  bit<16> value;
+}
+header variables_t {
+  
+}
+header slices_preamble_t {
+  bit<8> num_items_slices;
+}
+header slices_item_t {
+  bit<32> value;
+}
+struct hydra_header_t {
+  eth_type2_t eth_type;
+  variables_t variables;
+  slices_preamble_t slices_preamble;
+  slices_item_t[3] slices;
+}
+struct hydra_metadata_t {
+  bool reject0;
+  bit<8> num_list_items;
+  bit<32> switch_slice;
+}
+parser CheckerHeaderParser(packet_in packet, out hydra_header_t hydra_header,
+                           inout hydra_metadata_t hydra_metadata) {
+  state start {
+    packet.extract(hydra_header.eth_type);
+    transition parse_variables;
+  }
+  state parse_variables {
+    packet.extract(hydra_header.variables);
+    transition parse_slices_preamble;
+  }
+  state parse_slices_preamble
+    {
+    packet.extract(hydra_header.slices_preamble);
+    hydra_metadata.num_list_items =
+    hydra_header.slices_preamble.num_items_slices;
+    transition select(hydra_metadata.num_list_items) {
+      0: accept;
+      default: parse_slices;
+    }
+  }
+  state parse_slices
+    {
+    packet.extract(hydra_header.slices.next);
+    hydra_metadata.num_list_items = hydra_metadata.num_list_items-1;
+    transition select(hydra_metadata.num_list_items) {
+      0: accept;
+      default: parse_slices;
+    }
+  }
+}
+control CheckerHeaderDeparser(packet_out packet,
+                              in hydra_header_t hydra_header) {
+  apply
+    {
+    packet.emit(hydra_header.eth_type);
+    packet.emit(hydra_header.variables);
+    packet.emit(hydra_header.slices_preamble);
+    packet.emit(hydra_header.slices);
+  }
+}
+control initControl(inout hydra_header_t hydra_header,
+                    inout hydra_metadata_t hydra_metadata) {
+  action init_cp_vars(bit<32> switch_slice)
+    {
+    hydra_metadata.switch_slice = switch_slice;
+  }
+  table tb_init_cp_vars {
+    key = {
+      
+    }
+    actions = {
+      init_cp_vars;
+    }
+    size = 2;
+  }
+  apply
+    {
+    tb_init_cp_vars.apply();
+    hydra_header.eth_type.setValid();
+    hydra_header.eth_type.value = ETHERTYPE_CHECKER;
+    hydra_header.slices_preamble.setValid();
+    hydra_header.slices_preamble.num_items_slices = 0;
+  }
+}
+control telemetryControl(inout hydra_header_t hydra_header,
+                         inout hydra_metadata_t hydra_metadata) {
+  action init_cp_vars(bit<32> switch_slice)
+    {
+    hydra_metadata.switch_slice = switch_slice;
+  }
+  table tb_init_cp_vars {
+    key = {
+      
+    }
+    actions = {
+      init_cp_vars;
+    }
+    size = 2;
+  }
+  apply
+    {
+    tb_init_cp_vars.apply();
+    hydra_header.slices.push_front(1);
+    hydra_header.slices[0].setValid();
+    hydra_header.slices[0].value = 1;
+    hydra_header.slices_preamble.num_items_slices = hydra_header.slices_preamble.num_items_slices + 1;
+  }
+}
+control checkerControl(inout hydra_header_t hydra_header,
+                       inout hydra_metadata_t hydra_metadata) {
+  action init_cp_vars(bit<32> switch_slice)
+    {
+    hydra_metadata.switch_slice = switch_slice;
+  }
+  table tb_init_cp_vars {
+    key = {
+      
+    }
+    actions = {
+      init_cp_vars;
+    }
+    size = 2;
+  }
+  apply
+    {
+    tb_init_cp_vars.apply();
+    bit<32> prev_slice = hydra_header.slices[0].value;
+    bit<32> slice;
+    if (hydra_header.slices[0].isValid())
+      {
+      slice = hydra_header.slices[0].value;
+      if (prev_slice!=slice) {
+        hydra_metadata.reject0 = true;
+      }
+      prev_slice = slice;
+      if (hydra_header.slices[1].isValid())
+        {
+        slice = hydra_header.slices[1].value;
+        if (prev_slice!=slice) {
+          hydra_metadata.reject0 = true;
+        }
+        prev_slice = slice;
+        if (hydra_header.slices[2].isValid())
+          {
+          slice = hydra_header.slices[2].value;
+          if (prev_slice!=slice) {
+            hydra_metadata.reject0 = true;
+          }
+          prev_slice = slice;
+        }
+      }
+    }
+
+    hydra_header.eth_type.setInvalid();
+    hydra_header.variables.setInvalid();
+    hydra_header.slices_preamble.setInvalid();
+    hydra_header.slices[0].setInvalid();
+    hydra_header.slices[1].setInvalid();
+    hydra_header.slices[2].setInvalid();
+  }
+}
+
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_HYDRA = 0x5678;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+}
+
+header eth_type_t {
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+struct metadata {
+    bool first_hop;
+    bool last_hop;
+    hydra_metadata_t hydra_metadata;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    hydra_header_t hydra_header;
+    eth_type_t eth_type;
+    ipv4_t       ipv4;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    CheckerHeaderParser() hydra_parser;
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition parse_tele_or_eth_type;
+    }
+
+    state parse_tele_or_eth_type {
+        transition select(packet.lookahead<bit<16>>()) {
+            TYPE_HYDRA: parse_hydra_headers;
+            default: parse_eth_type;
+        }
+    }
+
+    state parse_hydra_headers {
+        hydra_parser.apply(packet, hdr.hydra_header, meta.hydra_metadata);
+        transition parse_eth_type;
+    }
+
+    state parse_eth_type {
+        packet.extract(hdr.eth_type);
+        transition select(hdr.eth_type.etherType) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+}
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
+        standard_metadata.egress_spec = port;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+            NoAction;
+        }
+        size = 1024;
+        default_action = drop();
+    }
+
+    action set_first_hop() {
+        meta.first_hop = true;
+    }
+
+    table tb_check_first_hop {
+        key = {
+            standard_metadata.ingress_port: exact;
+        }
+        actions = {
+            @defaultonly NoAction;
+            set_first_hop;
+        }
+        const default_action = NoAction();
+        size = 512;
+    }
+
+    apply {
+        tb_check_first_hop.apply();
+        if (meta.first_hop) {
+            initControl.apply(hdr.hydra_header, meta.hydra_metadata);
+        }
+        if (hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+
+    action set_last_hop() {
+        meta.last_hop = true;
+    }
+
+    table tb_check_last_hop {
+        key = {
+            standard_metadata.egress_port: exact;
+        }
+        actions = {
+            @defaultonly NoAction;
+            set_last_hop;
+        }
+        const default_action = NoAction();
+        size = 512;
+    }
+
+    apply {  
+        telemetryControl.apply(hdr.hydra_header, meta.hydra_metadata);
+        tb_check_last_hop.apply();
+        if (meta.last_hop) {
+            checkerControl.apply(hdr.hydra_header, meta.hydra_metadata);
+        }
+        if (meta.hydra_metadata.reject0) {
+            mark_to_drop(standard_metadata);
+        }
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+        hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+
+    CheckerHeaderDeparser() hydra_deparser;
+
+    apply {
+        packet.emit(hdr.ethernet);
+        hydra_deparser.apply(packet, hdr.hydra_header);
+        packet.emit(hdr.eth_type);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000047__raw-repositories__bennyrubin__HydraCode.p4

@@ -0,0 +1,487 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x800;
+const bit<16> TYPE_SRCROUTING = 0x1234;
+const bit<16> TYPE_HYDRA = 0x5678;
+
+
+#define MAX_HOPS 9
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header srcRoute_t {
+    bit<1>    bos;
+    bit<15>   port;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+
+#include <v1model.p4> 
+
+#define ETHERTYPE_CHECKER 0x5678;
+
+
+header eth_type2_t {
+  bit<16> value;
+}
+header variables_t {
+  bit<7> index;
+  bool to_reject;
+}
+header expected_path_preamble_t {
+  bit<8> num_items_expected_path;
+}
+header expected_path_item_t {
+  bit<16> value;
+}
+struct hydra_header_t {
+  eth_type2_t eth_type;
+  variables_t variables;
+  expected_path_preamble_t expected_path_preamble;
+  expected_path_item_t[3] expected_path;
+}
+struct hydra_metadata_t {
+  bool reject0;
+  bit<8> num_list_items;
+  bit<16> switch_id;
+  bit<32> expected_s3_dict_var0;
+  bit<32> expected_s2_dict_var0;
+  bit<32> expected_s1_dict_var0;
+  bit<16> expected_s1_dict;
+  bit<16> expected_s2_dict;
+  bit<16> expected_s3_dict;
+}
+parser CheckerHeaderParser(packet_in packet, out hydra_header_t hydra_header,
+                           inout hydra_metadata_t hydra_metadata) {
+  state start {
+    packet.extract(hydra_header.eth_type);
+    transition parse_variables;
+  }
+  state parse_variables {
+    packet.extract(hydra_header.variables);
+    transition parse_expected_path_preamble;
+  }
+
+  state parse_expected_path_preamble
+    {
+    packet.extract(hydra_header.expected_path_preamble);
+    hydra_metadata.num_list_items =
+    hydra_header.expected_path_preamble.num_items_expected_path;
+    transition select(hydra_metadata.num_list_items) {
+      0: accept;
+      default: parse_expected_path;
+    }
+  }
+
+  state parse_expected_path
+    {
+    packet.extract(hydra_header.expected_path.next);
+    hydra_metadata.num_list_items = hydra_metadata.num_list_items-1;
+    transition select(hydra_metadata.num_list_items) {
+      0: accept;
+      default: parse_expected_path;
+    }
+  }
+}
+control CheckerHeaderDeparser(packet_out packet,
+                              in hydra_header_t hydra_header) {
+  apply
+    {
+    packet.emit(hydra_header.eth_type);
+    packet.emit(hydra_header.variables);
+    packet.emit(hydra_header.expected_path_preamble);
+    packet.emit(hydra_header.expected_path);
+  }
+}
+control initControl(in ipv4_t ipv4,
+                    inout hydra_header_t hydra_header,
+                    inout hydra_metadata_t hydra_metadata) {
+
+  action lkp_cp_dict_expected_s3_dict(bit<16> expected_s3_dict)
+    {
+    hydra_metadata.expected_s3_dict = expected_s3_dict;
+  }
+  table tbl_lkp_cp_dict_expected_s3_dict
+    {
+    key = {
+      hydra_metadata.expected_s3_dict_var0: lpm;
+    }
+    actions = {
+      lkp_cp_dict_expected_s3_dict;
+    }
+    size = 64;
+  }
+
+  action lkp_cp_dict_expected_s2_dict(bit<16> expected_s2_dict)
+  {
+    hydra_metadata.expected_s2_dict = expected_s2_dict;
+  }
+
+  table tbl_lkp_cp_dict_expected_s2_dict
+    {
+    key = {
+      hydra_metadata.expected_s2_dict_var0: lpm;
+    }
+    actions = {
+      lkp_cp_dict_expected_s2_dict;
+    }
+    size = 64;
+  }
+
+  action lkp_cp_dict_expected_s1_dict(bit<16> expected_s1_dict)
+  {
+    hydra_metadata.expected_s1_dict = expected_s1_dict;
+  }
+
+  table tbl_lkp_cp_dict_expected_s1_dict
+    {
+    key = {
+      hydra_metadata.expected_s1_dict_var0: lpm;
+    }
+    actions = {
+      lkp_cp_dict_expected_s1_dict;
+    }
+    size = 64;
+  }
+
+  table tb_debug {
+    key = {
+      hydra_header.expected_path[0].value: exact;
+      hydra_header.expected_path[1].value: exact;
+      hydra_header.expected_path[2].value: exact;
+    }
+    actions = {
+      lkp_cp_dict_expected_s1_dict;
+    }
+    const entries = {
+            (0,0,0): lkp_cp_dict_expected_s1_dict(0);
+        }
+    size = 2;
+  }
+
+  apply
+    {
+    hydra_header.eth_type.setValid();
+    hydra_header.eth_type.value = ETHERTYPE_CHECKER;
+    hydra_header.variables.setValid();
+    hydra_header.variables.index = 0;
+    hydra_header.variables.to_reject = false;
+    hydra_header.expected_path_preamble.setValid();
+    hydra_metadata.expected_s3_dict_var0 = ipv4.dstAddr;
+
+// 167773188;
+    tbl_lkp_cp_dict_expected_s3_dict.apply();
+    hydra_header.expected_path.push_front(1);
+    hydra_header.expected_path[0].setValid();
+    hydra_header.expected_path[0].value =
+    hydra_metadata.expected_s3_dict;
+    hydra_metadata.expected_s2_dict_var0 = ipv4.dstAddr;
+    tbl_lkp_cp_dict_expected_s2_dict.apply();
+    hydra_header.expected_path.push_front(1);
+    hydra_header.expected_path[0].setValid();
+    hydra_header.expected_path[0].value =
+    hydra_metadata.expected_s2_dict;
+    hydra_metadata.expected_s1_dict_var0 = ipv4.dstAddr;
+    tbl_lkp_cp_dict_expected_s1_dict.apply();
+    hydra_header.expected_path.push_front(1);
+    hydra_header.expected_path[0].setValid();
+    hydra_header.expected_path[0].value =
+    hydra_metadata.expected_s1_dict;
+    hydra_header.expected_path_preamble.num_items_expected_path = 3;
+    tb_debug.apply();
+  }
+}
+control telemetryControl(
+                         inout hydra_header_t hydra_header,
+                         inout hydra_metadata_t hydra_metadata) {
+  action init_cp_vars(bit<16> switch_id)
+    {
+    hydra_metadata.switch_id = switch_id;
+  }
+  table tb_init_cp_vars {
+    key = {
+     hydra_header.eth_type.isValid(): exact; 
+    }
+    actions = {
+      init_cp_vars;
+    }
+    size = 2;
+  }
+
+    table tb_debug {
+    key = {
+      hydra_header.expected_path[0].value: exact;
+      hydra_header.expected_path[1].value: exact;
+      hydra_header.expected_path[2].value: exact;
+      hydra_metadata.switch_id: exact;
+      hydra_header.variables.index: exact; 
+    }
+    actions = {
+      init_cp_vars;
+    }
+    const entries = {
+            (0,0,0,0,0): init_cp_vars(0);
+        }
+    size = 2;
+  }
+
+  apply {
+    tb_init_cp_vars.apply();
+    tb_debug.apply();
+    if (hydra_header.expected_path[hydra_header.variables.index].value != hydra_metadata.switch_id)
+    {
+      hydra_header.variables.to_reject = true;
+    } else {
+      if (hydra_header.variables.index<3) {
+        hydra_header.variables.index = hydra_header.variables.index+1;
+      } else {
+        hydra_header.variables.to_reject = true;
+      }
+    }
+  }
+}
+control checkerControl(
+                       inout hydra_header_t hydra_header,
+                       inout hydra_metadata_t hydra_metadata) {
+  
+  apply
+    {
+    
+    if (hydra_header.variables.to_reject) {
+      hydra_metadata.reject0 = true;
+    }
+    hydra_header.eth_type.setInvalid();
+    hydra_header.variables.setInvalid();
+    hydra_header.expected_path_preamble.setInvalid();
+    hydra_header.expected_path[0].setInvalid();
+    hydra_header.expected_path[1].setInvalid();
+    hydra_header.expected_path[2].setInvalid();
+  }
+}
+
+
+
+
+struct metadata {
+    bool first_hop;
+    bool last_hop; 
+    hydra_metadata_t hydra_metadata;
+}
+
+struct headers {
+    ethernet_t              ethernet;
+    hydra_header_t          hydra_header;
+    srcRoute_t[MAX_HOPS]    srcRoutes;
+    ipv4_t                  ipv4;
+}
+
+
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    CheckerHeaderParser() hydra_parser;
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition parse_hydra_or_eth_type;
+    }
+
+    state parse_hydra_or_eth_type {
+        transition select(packet.lookahead<bit<16>>()) {
+            TYPE_HYDRA: parse_hydra_headers;
+            default: parse_srcRouting_first;
+        }
+    }
+
+    state parse_hydra_headers {
+        hydra_parser.apply(packet, hdr.hydra_header, meta.hydra_metadata);
+        transition parse_srcRouting_first;
+    }
+
+    state parse_srcRouting_first {
+        transition select(hdr.ethernet.etherType) {
+            TYPE_SRCROUTING: parse_srcRouting;
+            default: accept;
+        }
+    }
+
+    state parse_srcRouting {
+        packet.extract(hdr.srcRoutes.next);
+        transition select(hdr.srcRoutes.last.bos) {
+            1: parse_ipv4;
+            default: parse_srcRouting;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action srcRoute_nhop() {
+        standard_metadata.egress_spec = (bit<9>)hdr.srcRoutes[0].port;
+        hdr.srcRoutes.pop_front(1);
+    }
+
+    action srcRoute_finish() {
+        hdr.ethernet.etherType = TYPE_IPV4;
+    }
+
+    action update_ttl(){
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }
+
+    action set_first_hop() {
+        meta.first_hop = true;
+    }
+
+    table tb_check_first_hop {
+        key = {
+            standard_metadata.ingress_port: exact;
+        }
+        actions = {
+            @defaultonly NoAction;
+            set_first_hop;
+        }
+        const default_action = NoAction();
+        size = 512;
+    }
+
+    apply {
+
+        tb_check_first_hop.apply();
+        if (meta.first_hop) {
+            initControl.apply(hdr.ipv4, hdr.hydra_header, meta.hydra_metadata);
+        }
+
+        if (hdr.srcRoutes[0].isValid()){
+            if (hdr.srcRoutes[0].bos == 1){
+                srcRoute_finish();
+            }
+            srcRoute_nhop();
+            if (hdr.ipv4.isValid()){
+                update_ttl();
+            }
+        }else{
+            drop();
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    action set_last_hop() {
+        meta.last_hop = true;
+    }
+
+    table tb_check_last_hop {
+        key = {
+            standard_metadata.egress_port: exact;
+        }
+        actions = {
+            @defaultonly NoAction;
+            set_last_hop;
+        }
+        const default_action = NoAction();
+        size = 512;
+    }
+
+    apply {  
+        telemetryControl.apply(hdr.hydra_header, meta.hydra_metadata);
+        tb_check_last_hop.apply();
+        if (meta.last_hop) {
+            checkerControl.apply(hdr.hydra_header, meta.hydra_metadata);
+        }
+        if (meta.hydra_metadata.reject0) {
+            mark_to_drop(standard_metadata);
+        }
+    }
+}
+
+
+
+control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+
+    CheckerHeaderDeparser() hydra_deparser;
+
+    apply {
+        packet.emit(hdr.ethernet);
+        hydra_deparser.apply(packet, hdr.hydra_header);
+        packet.emit(hdr.srcRoutes);
+        packet.emit(hdr.ipv4);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000048__raw-repositories__cslev__p4.p4

@@ -0,0 +1,114 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t   ethernet;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition accept;
+    }
+
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {   
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action portfwd(egressSpec_t port) {
+      standard_metadata.egress_spec = port;
+    }
+
+
+    table port_exact {
+      key = {
+        standard_metadata.ingress_port: exact;
+      }
+      actions = {
+        portfwd;
+        drop;
+      }
+      size = 10;
+      default_action = drop;
+    }
+    
+    
+    apply {
+      port_exact.apply();
+        
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply { }
+
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+      packet.emit(hdr.ethernet);
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000049__raw-repositories__dcomp-leris__VR-AR-CG-network-telemetry.p4

@@ -0,0 +1,252 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4  = 0x0800;
+const bit<8> IP_PROTO = 253;
+
+
+#define PKT_INSTANCE_TYPE_NORMAL 0
+#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1
+#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2
+#define PKT_INSTANCE_TYPE_COALESCED 3
+#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4
+
+
+#define MAX_HOPS 10
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+typedef bit<31> switchID_v;
+typedef bit<9> ingress_port_v;
+typedef bit<9> egress_port_v;
+typedef bit<9>  egressSpec_v;
+typedef bit<48>  ingress_global_timestamp_v;
+typedef bit<48>  egress_global_timestamp_v;
+typedef bit<32>  enq_timestamp_v;
+typedef bit<19> enq_qdepth_v;
+typedef bit<32> deq_timedelta_v;
+typedef bit<19> deq_qdepth_v;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header nodeCount_h{
+    bit<16>  count;
+}
+
+header InBandNetworkTelemetry_h {
+    switchID_v swid;
+    ingress_port_v ingress_port;
+    egress_port_v egress_port;
+    egressSpec_v egress_spec;
+    ingress_global_timestamp_v ingress_global_timestamp;
+    egress_global_timestamp_v egress_global_timestamp;
+    enq_timestamp_v enq_timestamp;
+    enq_qdepth_v enq_qdepth;
+    deq_timedelta_v deq_timedelta;
+    deq_qdepth_v deq_qdepth;
+}
+
+
+struct ingress_metadata_t {
+    bit<16>  count;
+}
+
+struct parser_metadata_t {
+    bit<16>  remaining;
+}
+
+
+struct metadata {
+    ingress_metadata_t   ingress_metadata;
+    parser_metadata_t   parser_metadata;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+    nodeCount_h        nodeCount;
+    InBandNetworkTelemetry_h[MAX_HOPS] INT;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+          TYPE_IPV4: parse_ipv4;
+          default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+      packet.extract(hdr.ipv4);
+      transition select(hdr.ipv4.protocol) {
+        IP_PROTO: parse_count;
+        default: accept;
+      }
+    }
+
+    state parse_count{
+        packet.extract(hdr.nodeCount);
+        meta.parser_metadata.remaining = hdr.nodeCount.count;
+        transition select(meta.parser_metadata.remaining) {
+            0 : accept;
+            default: parse_int;
+        }
+    }
+
+    state parse_int {
+        packet.extract(hdr.INT.next);
+        meta.parser_metadata.remaining = meta.parser_metadata.remaining - 1;
+        transition select(meta.parser_metadata.remaining) {
+            0 : accept;
+            default: parse_int;
+        }
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action send_back() {
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+        bit<48> tmp_mac;
+        bit<32> tmp_ip;
+
+        tmp_mac = hdr.ethernet.srcAddr;
+        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = tmp_mac;
+
+        tmp_ip = hdr.ipv4.srcAddr;
+        hdr.ipv4.srcAddr = hdr.ipv4.dstAddr;
+        hdr.ipv4.dstAddr = tmp_ip;
+    }
+
+    apply {
+        if (hdr.nodeCount.isValid() && standard_metadata.instance_type == PKT_INSTANCE_TYPE_INGRESS_RECIRC) {
+            send_back();
+        } else {
+            standard_metadata.egress_spec = (standard_metadata.ingress_port+1)%2;
+        }
+        
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+
+    action my_recirculate() {
+        recirculate_preserving_field_list(0);
+    }
+    
+    action add_swtrace() {
+        hdr.nodeCount.count = hdr.nodeCount.count + 1;
+        hdr.INT.push_front(1);
+        hdr.INT[0].setValid();
+
+//1 para downlink, 2 para uplink
+        if (hdr.nodeCount.count == 2){
+            hdr.INT[0].swid = 1;
+        } else {
+            hdr.INT[0].swid = 2;
+        }
+        hdr.INT[0].ingress_port = (ingress_port_v)standard_metadata.ingress_port;
+        hdr.INT[0].egress_port = (egress_port_v)standard_metadata.egress_port;
+        hdr.INT[0].egress_spec = (egressSpec_v)standard_metadata.egress_spec;
+        hdr.INT[0].ingress_global_timestamp = (ingress_global_timestamp_v)standard_metadata.ingress_global_timestamp;
+        hdr.INT[0].egress_global_timestamp = (egress_global_timestamp_v)standard_metadata.egress_global_timestamp;
+        hdr.INT[0].enq_timestamp = (enq_timestamp_v)standard_metadata.enq_timestamp;
+        hdr.INT[0].enq_qdepth = (enq_qdepth_v)standard_metadata.enq_qdepth;
+        hdr.INT[0].deq_timedelta = (deq_timedelta_v)standard_metadata.deq_timedelta;
+        hdr.INT[0].deq_qdepth = (deq_qdepth_v)standard_metadata.deq_qdepth;
+        
+        hdr.ipv4.totalLen = hdr.ipv4.totalLen + 32;
+
+     }
+    
+    apply {
+
+        if (hdr.nodeCount.isValid()) {
+            add_swtrace();
+            if (hdr.nodeCount.count < 2){
+                my_recirculate();
+            }
+        }
+      }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+     }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.nodeCount);
+        packet.emit(hdr.INT);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000050__raw-repositories__DETERMINISTIC6G__det6g-blog-prog-soft-tsn-switch.p4

@@ -0,0 +1,168 @@
+#include <core.p4>
+#include <v1model.p4>
+
+const bit<16> TYPE_IPV4 = 0x0800;
+const bit<16> TYPE_VLAN = 0x8100;
+
+const bit<8>  TYPE_UDP  = 0x11;
+
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header vlan_h {
+    bit<3> pcp;
+    bit<1> dei;
+    bit<12> vid;
+    bit<16> etherType;
+}
+
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header udp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<16> udpTotalLen;
+    bit<16> checksum;
+}
+
+struct metadata {
+
+/* empty */
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    vlan_h       vlan;
+    ipv4_t       ipv4;
+    udp_t        udp;
+}
+
+parser myParser(packet_in packet, out headers hdr,
+    inout metadata meta, inout standard_metadata_t std_data) {
+
+    state start {
+
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType){
+            TYPE_VLAN: parse_vlan; 
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_vlan {
+        packet.extract(hdr.vlan);
+        transition select(hdr.vlan.etherType){
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            TYPE_UDP: parse_udp;
+            default : accept;
+        }
+    }
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;
+    }
+}
+
+
+control myVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+control myIngress(inout headers hdr, inout metadata meta,
+                  inout standard_metadata_t std_data) {
+    apply {
+
+// naif routing
+        if( std_data.ingress_port == 1 )
+            std_data.egress_spec = 2;
+        else
+           std_data.egress_spec = 1;
+    }
+}
+
+
+
+register <bit<48>>(1) last_tc0_packet_ts;
+
+control myEgress(inout headers hdr, inout metadata meta,
+                 inout standard_metadata_t std_data) {
+    bit<48> ts;
+    bit<48> last_ts;
+    apply {
+
+//enable VLAN if it is not existing
+        if( ! hdr.vlan.isValid() ){
+            hdr.vlan.setValid();
+            hdr.vlan.etherType = hdr.ethernet.etherType;
+            hdr.ethernet.etherType = TYPE_VLAN;
+        }
+
+        @atomic {
+
+//get ingress timestamp (in microsecond) of the current packet
+            ts = std_data.ingress_global_timestamp;
+
+//dynamically adjust VLAN PCP
+            if( hdr.udp.isValid() && hdr.udp.dstPort == 1000 ){
+                hdr.vlan.pcp = 0;
+
+                last_tc0_packet_ts.write( 0, ts);
+            } else {
+
+// get the timestamp from the first element of the array
+                last_tc0_packet_ts.read( last_ts, 0 );
+                if( ts - last_ts > 1*1000*1000 )
+                    hdr.vlan.pcp = 0;
+                else
+                    hdr.vlan.pcp = 1;
+            }
+        }
+    }
+}
+
+control myComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {}
+}
+
+control myDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.vlan);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.udp);
+    }
+}
+
+
+//switch architecture
+V1Switch( 
+  myParser(), myVerifyChecksum(), myIngress(), myEgress(), myComputeChecksum(), myDeparser()
+) main;

individual_files/000051__raw-repositories__emdneto__dh-aes-p4.p4

@@ -0,0 +1,172 @@
+// Standard headers
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+// useful for DH
+typedef bit<256> keys_t;
+typedef bit<48> macAddr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16> etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    macAddr_t srcAddr;
+    macAddr_t dstAddr;
+}
+
+header tcp_t{
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<4>  res;
+    bit<1>  cwr;
+    bit<1>  ece;
+    bit<1>  urg;
+    bit<1>  ack;
+    bit<1>  psh;
+    bit<1>  rst;
+    bit<1>  syn;
+    bit<1>  fin;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+#define ETHERTYPE_AES_TOY 0x9999
+
+header aes_inout_t {
+    bit<128> value;
+}
+
+struct my_headers_t {
+    ethernet_t            ethernet;
+    aes_inout_t           aes_inout;
+}
+
+header aes_meta_t {
+
+// internal state, 4 rows
+}
+
+header dh_meta_t {
+    bit<256> secrect;
+    bit<256> pu;
+}
+struct my_metadata_t {
+    aes_meta_t aes;
+}
+
+parser MyParser(
+    packet_in             packet,
+    out   my_headers_t    hdr,
+    inout my_metadata_t   meta,
+    inout standard_metadata_t standard_metadata)
+{
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+           ETHERTYPE_AES_TOY    : parse_aes;
+           default              : accept;
+        }
+    }
+
+    state parse_aes {
+        packet.extract(hdr.aes_inout);
+        transition accept;
+    }
+}
+
+control MyVerifyChecksum(inout my_headers_t hdr, inout my_metadata_t meta) {
+    apply { }
+}
+
+control MyIngress(
+    inout my_headers_t         hdr,
+    inout my_metadata_t        meta,
+    inout standard_metadata_t  standard_metadata)
+{
+
+    action l2_fwd() {
+        hdr.aes_inout.setValid();
+    }
+
+    action set_egress_spec(bit<9> port) {
+        standard_metadata.egress_spec = port;
+    }
+
+    table forward {
+        key = {
+            standard_metadata.ingress_port: exact;
+        }
+        actions = {
+            set_egress_spec;
+            NoAction;
+        }
+        size = 1024;
+        default_action = NoAction();
+    }
+
+    apply {
+
+        if (forward.apply().hit) {
+
+            if (hdr.ethernet.etherType == 0x9999) {
+                l2_fwd();
+            }
+        }
+    }
+}
+
+control MyEgress(
+    inout my_headers_t        hdr,
+    inout my_metadata_t       meta,
+    inout standard_metadata_t standard_metadata) {
+
+    apply {
+
+    }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.aes_inout);
+    }
+}
+
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000052__raw-repositories__epap011__P4Lang-SimpleLoadBalancer.p4

@@ -0,0 +1,416 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+const bit<16> TYPE_IPV4     = 0x800;
+const bit<16> TYPE_ARP      = 0x806;
+const bit<32> serviceIP     = 0xa010203;
+const bit<48> lbMAC         = 0xa0000000001;
+
+
+
+
+/* type definitions for ease of reference */
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+
+/* ethernet frame header */
+header ethernet_t {
+    macAddr_t   dstAddr;
+    macAddr_t   srcAddr;
+    bit<16>     etherType;
+}
+
+
+/* ARP packet header */
+header arp_t {
+    bit<16>     hwType;
+    bit<16>     protoType;
+    bit<8>      hwAddrLen;
+    bit<8>      protoAddrLen;
+    bit<16>     opCode;
+    macAddr_t   hwSrcAddr;
+    ip4Addr_t   protoSrcAddr;
+    macAddr_t   hwDstAddr;
+    ip4Addr_t   protoDstAddr;
+}
+
+
+/* IP packet header */
+header ipv4_t {
+    bit<4>      version;
+    bit<4>      ihl;
+    bit<8>      diffserv;
+    bit<16>     totalLen;
+    bit<16>     identification;
+    bit<3>      flags;
+    bit<13>     fragOffset;
+    bit<8>      ttl;
+    bit<8>      protocol;
+    bit<16>     hdrChecksum;
+    ip4Addr_t   srcAddr;
+    ip4Addr_t   dstAddr;
+}
+
+
+/* metadata carried by the packet through the processing pipelines */
+struct metadata {
+    macAddr_t   dstMAC;
+
+// the dst MAC to which the packet should be directed on L2
+    bit<1>      isClient;
+
+// whether the src IP of the packet belongs to a client
+    bit<1>      isServer;
+
+// whether the src IP of the packet belongs to a server
+    bit<8>      srcGroup;
+
+// the group of the src host
+    bit<8>      dstGroup;
+
+// the group of the dst host
+}
+
+struct headers {
+    ethernet_t  ethernet;
+    arp_t       arp;
+    ipv4_t      ipv4;
+}
+
+
+
+parser SLBParser(packet_in packet,
+                 out headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+
+
+/* begin with pointing to Ethernet frame parser */
+    state start {
+        transition parse_ethernet;
+    }
+
+
+/* parser ethernet frame */
+    state parse_ethernet {
+
+/* WRITE YOUR CODE HERE */
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_ARP: parse_arp;
+            TYPE_IPV4: parse_ipv4;
+            default:accept;
+        }
+
+    }
+
+    state parse_arp {
+        packet.extract(hdr.arp);
+        transition accept;
+
+// accept; the ARP packet will be pushed to ingress pipeline
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+
+// accept; the IP packet will be pushed to ingress pipeline
+        transition accept;
+    }
+
+}
+
+
+
+control SLBVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+
+control SLBIngress(inout headers hdr,
+                   inout metadata meta,
+                   inout standard_metadata_t standard_metadata) {
+
+
+/* Action that instructs the pipeline to drop a packet */
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+
+/* Action that transforms an ARP request into a suitable ARP reply */
+    action arp_request_to_reply(macAddr_t srcMAC, macAddr_t dstMAC, ip4Addr_t srcIP, ip4Addr_t dstIP) {
+
+/* WRITE YOUR CODE HERE */
+        hdr.ethernet.srcAddr   = dstMAC;
+        hdr.ethernet.dstAddr   = srcMAC;
+        
+        hdr.arp.hwSrcAddr    = dstMAC;
+        hdr.arp.hwDstAddr    = srcMAC;
+        hdr.arp.protoSrcAddr = dstIP;
+        hdr.arp.protoDstAddr = srcIP;
+        hdr.arp.opCode       = 2;
+        
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+
+// the reply should be sent out of the in-port
+    }
+
+
+    action set_egress_metadata(macAddr_t dstMAC, egressSpec_t port) {
+        meta.dstMAC = dstMAC;
+        standard_metadata.egress_spec = port;
+    }
+
+
+    action set_client_metadata(ip4Addr_t firstAllowedReplica, ip4Addr_t lastAllowedReplica) {
+        meta.isClient = 1;
+        meta.isServer = 0;
+
+/* WRITE YOUR CODE HERE */
+        random(hdr.ipv4.dstAddr, firstAllowedReplica, lastAllowedReplica);
+    }
+
+
+/* Action that updates metadata with the info that the src IP does not belong to a client */
+    action unset_client_metadata() {
+        meta.isClient = 0;
+    }
+
+
+/* Action that updates metadata with the info that the src IP belongs to a server */
+    action set_server_metadata() {
+        meta.isServer = 1;
+        meta.isClient = 0;
+    }
+
+
+/* Action that updates metadata with the info that the src IP does not belong to a server */
+    action unset_server_metadata() {
+        meta.isServer = 0;
+    }
+
+
+/* Action that sets the group membership for a src host */
+    action set_src_membership(bit<8> group) {
+        meta.srcGroup = group;
+    }
+
+
+/* Action that sets the group membership for a dst host */
+    action set_dst_membership(bit<8> group) {
+        meta.dstGroup = group;
+    }
+
+
+/* Table that stores the mapping between dst IP and dst MAC and egress port */
+    table arpmap {
+
+/* WRITE YOUR CODE HERE */
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            set_egress_metadata;
+        }
+    }
+
+
+/* Table that stores the info that a certain IP belongs to a client */
+    table ipv4_clients {
+        key = {
+            hdr.ipv4.srcAddr: lpm;
+        }
+        actions = {
+            set_client_metadata;
+            unset_client_metadata;
+        }
+    }
+
+
+/* Table that stores the info that a certain IP belongs to a server */
+    table ipv4_servers {
+
+/* WRITE YOUR CODE HERE */
+        key = {
+            hdr.ipv4.srcAddr: lpm;
+        }
+        actions = {
+            set_server_metadata;
+            unset_server_metadata;
+        }
+    }
+
+
+/* Table that stores the info about which src IP is member of which group */
+    table src_group_membership {
+
+/* WRITE YOUR CODE HERE */
+        key = {
+            hdr.ipv4.srcAddr: lpm;
+        }
+        actions = {
+            set_src_membership;
+        }
+    }
+
+
+/* Table that stores the info about which dst IP is member of which group */
+    table dst_group_membership {
+
+/* WRITE YOUR CODE HERE */
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        actions = {
+            set_dst_membership;
+        }
+    }
+
+
+/* Apply ingress workflow */
+    apply {
+        if (!(hdr.arp.isValid() || hdr.ipv4.isValid())) {
+            drop();
+
+// drop irrelevant/invalid traffic
+        }
+        else if (hdr.arp.isValid() && hdr.arp.opCode == 1) {
+
+// handle incoming ARP requests
+/* WRITE YOUR CODE HERE */
+            arp_request_to_reply(hdr.ethernet.srcAddr, lbMAC, hdr.arp.protoSrcAddr, hdr.arp.protoDstAddr);
+        }
+        else if (hdr.ipv4.isValid()) {
+
+/* WRITE YOUR CODE HERE */
+            ipv4_clients.apply();
+            ipv4_servers.apply();
+            src_group_membership.apply();
+            dst_group_membership.apply();
+
+            if (!((meta.isClient == 1) || meta.isServer == 1) || meta.srcGroup != meta.dstGroup) {
+                drop();
+
+// drop if not coming from client or server
+            }
+
+// of if the src/dst groups differ
+            else {
+                arpmap.apply();
+
+// prepare for egress
+            }
+        }
+    }
+}
+
+
+
+control SLBEgress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+
+/* Action that rewrites the header of client-to-server packets */
+    action rewrite_client_to_server() {
+
+/* WRITE YOUR CODE HERE */
+       hdr.ethernet.srcAddr = lbMAC;
+       hdr.ethernet.dstAddr = meta.dstMAC;
+    }
+
+
+/* Action that rewrites the header of server-to-client packets */
+    action rewrite_server_to_client() {
+
+/* WRITE YOUR CODE HERE */
+       hdr.ipv4.srcAddr     = serviceIP;
+
+       hdr.ethernet.srcAddr = lbMAC;
+       hdr.ethernet.dstAddr = meta.dstMAC;
+    }
+
+
+/* Apply egress workflow */
+    apply {
+        if (hdr.ipv4.isValid()) {
+
+/* WRITE YOUR CODE HERE */
+            if(meta.isClient == 1) {
+                rewrite_client_to_server();
+            }
+            else if(meta.isServer == 1) {
+                rewrite_server_to_client();
+            }
+        }
+    }
+}
+
+
+
+control SLBComputeChecksum(inout headers  hdr, inout metadata meta) {
+    apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+control SLBDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+
+// emit ethernet frame
+        packet.emit(hdr.arp);
+
+// emit ARP packet
+        packet.emit(hdr.ipv4);
+
+// emit IP packet
+    }
+}
+
+
+
+V1Switch(
+    SLBParser(),
+
+// parse packet headers
+    SLBVerifyChecksum(),
+
+// verify thet the packet is valid
+    SLBIngress(),
+
+// apply ingress logic
+    SLBEgress(),
+
+// apply egress logic
+    SLBComputeChecksum(),
+
+// compute the new checksum for the IP packet
+    SLBDeparser()
+
+// deparse (serialize) the packet
+) main;

individual_files/000053__raw-repositories__ebiken__p4srv6.p4

@@ -0,0 +1,1067 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+#ifdef _V1_MODEL_P4_
+typedef bit<9>  PortId_t;
+
+#endif /* _V1_MODEL_P4_ */
+
+
+
+
+
+#ifndef _HEADERS_
+#define _HEADERS_
+
+
+typedef bit<48> EthernetAddress;
+typedef bit<32> IPv4Address;
+typedef bit<128> IPv6Address;
+
+typedef bit<16> EthernetType;
+const EthernetType ETH_P_IPV4 = 16w0x0800;
+const EthernetType ETH_P_ARP  = 16w0x0806;
+const EthernetType ETH_P_VLAN = 16w0x8100;
+const EthernetType ETH_P_IPV6 = 16w0x86dd;
+
+
+typedef bit<8> IPProtocol;
+const IPProtocol IPPROTO_HOPOPT = 0;
+
+// IPv6 Hop-by-Hop Option
+const IPProtocol IPPROTO_ICMP = 1;
+const IPProtocol IPPROTO_IPV4 = 4;
+const IPProtocol IPPROTO_TCP = 6;
+const IPProtocol IPPROTO_UDP = 17;
+const IPProtocol IPPROTO_IPV6 = 41;
+const IPProtocol IPPROTO_ROUTE = 43;
+
+// Routing Header for IPv6
+const IPProtocol IPPROTO_FRAG = 44;
+
+// Fragment Header for IPv6
+const IPProtocol IPPROTO_GRE = 47;
+const IPProtocol IPPROTO_ICMPv6 = 58;
+
+// ICMP for IPv6
+const IPProtocol IPPROTO_NONXT = 59;
+
+// No Next Header for IPv6
+
+typedef bit<16> UDPPort;
+const UDPPort UDP_PORT_GTPC = 2123;
+const UDPPort UDP_PORT_GTPU = 2152;
+
+header Ethernet_h {
+    EthernetAddress dstAddr;
+    EthernetAddress srcAddr;
+    EthernetType etherType;
+}
+
+header IPv4_h {
+    bit<4> version;
+    bit<4> ihl;
+    bit<8> diffserv;
+    bit<16> totalLen;
+    bit<16> identification;
+    bit<3> flags;
+    bit<13> fragOffset;
+    bit<8> ttl;
+    IPProtocol protocol;
+    bit<16> hdrChecksum;
+    IPv4Address srcAddr;
+    IPv4Address dstAddr;
+}
+
+header IPv6_h {
+    bit<4> version;
+    bit<8> trafficClass;
+    bit<20> flowLabel;
+    bit<16> payloadLen;
+    bit<8> nextHdr;
+    bit<8> hopLimit;
+    IPv6Address srcAddr;
+    IPv6Address dstAddr;
+}
+
+header TCP_h {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seq;
+    bit<32> ack;
+    bit<4> dataOffset;
+    bit<4> res;
+    bit<8> flags;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+header UDP_h {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<16> length;
+    bit<16> checksum;
+}
+
+header ICMP_h {
+    bit<8> type;
+    bit<8> code;
+    bit<16> hdrChecksum;
+    bit<32> restOfHeader;
+
+}
+
+
+header SRH_h {
+    bit<8> nextHdr;
+    bit<8> hdrExtLen;
+    bit<8> routingType;
+    bit<8> segmentsLeft;
+    bit<8> lastEntry;
+    bit<8> flags;
+    bit<12> tag;
+    bit<4> gtpMessageType;
+
+// least significant 4 bits of tag field
+}
+
+header SRH_SegmentList_h {
+    bit<128> sid;
+}
+
+
+typedef bit<8> GTPv1Type;
+const GTPv1Type GTPV1_ECHO    = 1;
+
+// Echo Request
+const GTPv1Type GTPV1_ECHORES = 2;
+
+// Echo Response
+const GTPv1Type GTPV1_ERROR = 26;
+
+// Error Indication
+const GTPv1Type GTPV1_END  = 254;
+
+// End Marker
+const GTPv1Type GTPV1_GPDU = 255;
+
+// G-PDU
+
+
+// 3GPP TS 29.060 V15.3.0 (2018-12) "6 GTP Header"
+header GTPU_h {
+    bit<3>  version;
+
+// Version field: always 1 for GTPv1
+    bit<1>  pt;
+
+// Protocol Type (PT): GTP(1), GTP'(0)
+    bit<1>  reserved;
+
+// always zero (0)
+    bit<1>  e;
+
+// Extension Header flag (E)
+    bit<1>  s;
+
+// Sequence number flag (S): not present(0), present(1)
+    bit<1>  pn;
+
+// N-PDU Number flag (PN)
+    GTPv1Type messageType;
+    bit<16> messageLen;
+    bit<32> teid;
+
+    bit<16> seq;
+
+// Sequence Number
+    bit<8>  npdu;
+
+// N-PDU number
+    bit<8>  nextExtHdr;
+
+// Next Extention Header Type
+}
+
+
+
+#endif /* _HEADERS_ */
+
+
+#define SRH_SID_MAX 4
+
+// Max number of SIDs in SRH Segment List
+struct Header {
+    Ethernet_h ether;
+    IPv6_h ipv6;
+    SRH_h srh;
+    SRH_SegmentList_h[SRH_SID_MAX] srh_sid;
+
+    IPv4_h ipv4;
+    ICMP_h icmp;
+    TCP_h tcp;
+    UDP_h udp;
+    GTPU_h gtpu;
+
+// inner headers
+    Ethernet_h inner_ether;
+    IPv6_h inner_ipv6;
+    IPv4_h inner_ipv4;
+
+    TCP_h inner_tcp;
+    UDP_h inner_udp;
+}
+
+
+
+
+// Generic ingress metadata (architecture independent)
+struct IngressMetadata {
+
+// none defined yet
+}
+
+// Generic egress metadata (architecture independent)
+struct EgressMetadata {
+
+}
+struct SRv6Metadata {
+    bit<128> nextsid;
+    bit<4> gtp_message_type;
+
+    bit<8> gtpv1_type;
+
+}
+
+// User Metadata (for v1model)
+struct UserMetadata {
+    IngressMetadata ig_md;
+    EgressMetadata eg_md;
+    SRv6Metadata srv6;
+}
+
+
+
+
+#ifndef _PARSER_
+#define _PARSER_
+
+
+
+parser SwitchParser(
+            packet_in pkt,
+            out Header hdr,
+            inout UserMetadata user_md,
+            inout standard_metadata_t st_md) {
+
+    state start {
+        transition parse_ethernet;
+    }
+    state parse_ethernet {
+        pkt.extract(hdr.ether);
+        transition select(hdr.ether.etherType) {
+            ETH_P_IPV4 : parse_ipv4;
+            ETH_P_IPV6 : parse_ipv6;
+
+            default : accept;
+        }
+    }
+    state parse_ipv4 {
+        pkt.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            IPPROTO_TCP : parse_tcp;
+            IPPROTO_UDP : parse_udp;
+            default : accept;
+        }
+    }
+    state parse_ipv6 {
+        pkt.extract(hdr.ipv6);
+        transition select(hdr.ipv6.nextHdr) {
+            IPPROTO_TCP : parse_tcp;
+            IPPROTO_UDP : parse_udp;
+            IPPROTO_ROUTE : parse_srh;
+            IPPROTO_IPV4 : parse_inner_ipv4;
+            IPPROTO_IPV6 : parse_inner_ipv6;
+            default : accept;
+        }
+    }
+    state parse_tcp {
+        pkt.extract(hdr.tcp);
+        transition accept;
+    }
+    state parse_udp {
+        pkt.extract(hdr.udp);
+        transition select(hdr.udp.dstPort) {
+            UDP_PORT_GTPU: parse_gtpu;
+            default: accept;
+        }
+    }
+    state parse_gtpu {
+        pkt.extract(hdr.gtpu);
+        user_md.srv6.gtpv1_type = hdr.gtpu.messageType;
+        bit<4> ip_ver = pkt.lookahead<bit<4>>();
+        transition select(ip_ver) {
+            4w4 : parse_inner_ipv4;
+            4w6 : parse_inner_ipv6;
+            default : parse_inner_ether;
+        }
+    }
+    state parse_inner_ipv4 {
+        pkt.extract(hdr.inner_ipv4);
+        transition select(hdr.inner_ipv4.protocol) {
+            IPPROTO_TCP : parse_inner_tcp;
+            IPPROTO_UDP : parse_inner_udp;
+            default : accept;
+        }
+    }
+    state parse_inner_ipv6 {
+        pkt.extract(hdr.inner_ipv6);
+        transition select(hdr.inner_ipv6.nextHdr) {
+            IPPROTO_TCP : parse_inner_tcp;
+            IPPROTO_UDP : parse_inner_udp;
+            default : accept;
+        }
+    }
+    state parse_inner_ether {
+        pkt.extract(hdr.inner_ether);
+        transition accept;
+    }
+
+/*** PARSE SRH (SRv6) ***/
+    state parse_srh {
+        pkt.extract(hdr.srh);
+        user_md.srv6.gtp_message_type = hdr.srh.gtpMessageType;
+        transition parse_srh_sid_0;
+    }
+#define PARSE_SRH_SID(curr, next)               \
+    state parse_srh_sid_##curr {                \
+        pkt.extract(hdr.srh_sid[curr]);         \
+        transition select(hdr.srh.lastEntry) {  \
+            curr : parse_srh_next_header;       \
+            default : parse_srh_sid_##next;     \
+        }                                       \
+    }                                           \
+
+PARSE_SRH_SID(0, 1)
+PARSE_SRH_SID(1, 2)
+PARSE_SRH_SID(2, 3)
+    state parse_srh_sid_3 {
+        pkt.extract(hdr.srh_sid[3]);
+        transition select(hdr.srh.lastEntry) {
+            3 : parse_srh_next_header;
+
+// v1model: no default rule: all other packets rejected
+#ifndef _V1_MODEL_P4_
+            default : reject;
+
+// Too many SIDs
+#endif /* _V1_MODEL_P4_ */
+        }
+    }
+    state parse_srh_next_header {
+        transition select(hdr.srh.nextHdr) {
+            IPPROTO_TCP : parse_tcp;
+            IPPROTO_UDP : parse_udp;
+            IPPROTO_IPV4 : parse_inner_ipv4;
+            IPPROTO_IPV6 : parse_inner_ipv6;
+            default : accept;
+        }
+    }
+    state parse_inner_udp {
+        pkt.extract(hdr.inner_udp);
+        transition accept;
+    }
+    state parse_inner_tcp {
+        pkt.extract(hdr.inner_tcp);
+        transition accept;
+    }
+}
+
+
+
+
+control SwitchDeparser(
+            packet_out pkt,
+            in Header hdr) {
+
+    apply {
+        pkt.emit(hdr.ether);
+        pkt.emit(hdr.ipv6);
+        pkt.emit(hdr.srh);
+        pkt.emit(hdr.srh_sid);
+        pkt.emit(hdr.ipv4);
+
+        pkt.emit(hdr.tcp);
+        pkt.emit(hdr.udp);
+        pkt.emit(hdr.gtpu);
+        pkt.emit(hdr.inner_ether);
+        pkt.emit(hdr.inner_ipv6);
+        pkt.emit(hdr.inner_ipv4);
+        pkt.emit(hdr.inner_tcp);
+        pkt.emit(hdr.inner_udp);
+    }
+}
+#endif /* _PARSER_ */
+
+
+
+#ifndef _SRV6_
+#define _SRV6_
+
+control SRv6(
+    inout Header hdr,
+    inout UserMetadata user_md,
+    in PortId_t in_port,
+    inout PortId_t egress_port) {
+
+
+// Counters for actions in transit and end (localsid) behaviors.
+#ifdef _V1_MODEL_P4_
+
+// see v1model.p4 for counter definitions.
+    direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_v4;
+    direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_v6;
+    direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_udp;
+    direct_counter(CounterType.packets_and_bytes) cnt_srv6_e;
+    direct_counter(CounterType.packets_and_bytes) cnt_srv6_e_iif;
+#endif /* _V1_MODEL_P4_ */
+
+
+/*** HELPER ACTIONS */
+    action remove_srh_header() {
+        hdr.srh.setInvalid();
+
+        hdr.srh_sid[0].setInvalid();
+        hdr.srh_sid[1].setInvalid();
+        hdr.srh_sid[2].setInvalid();
+        hdr.srh_sid[3].setInvalid();
+        hdr.srh.setInvalid();
+    }
+
+
+/*** HELPER ACTIONS : PUSH SRH/SID */
+    action push_srh(bit<8> nextHdr, bit<8> hdrExtLen, bit<8> segmentsLeft, bit<8> lastEntry) {
+        hdr.srh.setValid();
+        hdr.srh.nextHdr = nextHdr;
+        hdr.srh.hdrExtLen = hdrExtLen;
+        hdr.srh.routingType = 4;
+
+// TBD, to be assigned by IANA (suggested value: 4)
+        hdr.srh.segmentsLeft = segmentsLeft;
+        hdr.srh.lastEntry = lastEntry;
+        hdr.srh.flags = 0;
+        hdr.srh.tag = 0;
+    }
+    action push_srh_sid1(
+            bit<8> nextHdr,
+            bit<8> segmentsLeft,
+            bit<128> sid1) {
+
+// SID List <sid1>
+        hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w24;
+
+// SRH(8) + SID(16)
+        push_srh(nextHdr, 8w2, segmentsLeft, 8w0);
+        hdr.srh_sid[0].setValid();
+        hdr.srh_sid[0].sid = sid1;
+    }
+    action push_srh_sid2(
+            bit<8> nextHdr,
+            bit<8> segmentsLeft,
+            bit<128> sid1, bit<128> sid2) {
+
+// SID List <sid1, sid2>
+        hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w40;
+
+// SRH(8) + SID(16)*2
+        push_srh(nextHdr, 8w4, segmentsLeft, 8w1);
+        hdr.srh_sid[0].setValid();
+        hdr.srh_sid[0].sid = sid2;
+        hdr.srh_sid[1].setValid();
+        hdr.srh_sid[1].sid = sid1;
+    }
+    action push_srh_sid3(
+            bit<8> nextHdr,
+            bit<8> segmentsLeft,
+            bit<128> sid1, bit<128> sid2, bit<128> sid3) {
+
+// SID List <sid1, sid2, sid3>
+        hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w56;
+
+// SRH(8) + SID(16)*3
+        push_srh(nextHdr, 8w6, segmentsLeft, 8w2);
+        hdr.srh_sid[0].setValid();
+        hdr.srh_sid[0].sid = sid3;
+        hdr.srh_sid[1].setValid();
+        hdr.srh_sid[1].sid = sid2;
+        hdr.srh_sid[2].setValid();
+        hdr.srh_sid[2].sid = sid1;
+    }
+    action push_srh_sid4(
+            bit<8> nextHdr,
+            bit<8> segmentsLeft,
+            bit<128> sid1, bit<128> sid2, bit<128> sid3, bit<128> sid4) {
+
+// SID List <sid1, sid2, sid3, sid4>
+        hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w72;
+
+// SRH(8) + SID(16)*4
+        push_srh(nextHdr, 8w8, segmentsLeft, 8w3);
+        hdr.srh_sid[0].setValid();
+        hdr.srh_sid[0].sid = sid4;
+        hdr.srh_sid[1].setValid();
+        hdr.srh_sid[1].sid = sid3;
+        hdr.srh_sid[2].setValid();
+        hdr.srh_sid[2].sid = sid2;
+        hdr.srh_sid[3].setValid();
+        hdr.srh_sid[3].sid = sid1;
+    }
+
+
+/*** TRANSIT ACTION & TABLES */
+
+
+// T.Insert will use ipv6.dstAddr as 1st SID. Thus, will have +1 SIDs.
+    action t_insert_sid1(bit<128> sid1) {
+        push_srh_sid2(hdr.ipv6.nextHdr, 1, sid1, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_v6.count();
+    }
+    action t_insert_sid2(bit<128> sid1, bit<128> sid2) {
+        push_srh_sid3(hdr.ipv6.nextHdr, 2, sid1, sid2, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_v6.count();
+    }
+    action t_insert_sid3(bit<128> sid1, bit<128> sid2, bit<128> sid3) {
+        push_srh_sid4(hdr.ipv6.nextHdr, 3, sid1, sid2, sid3, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_v6.count();
+    }
+
+
+    action t_m_gtp4_d_synthesize(bit<32> iw_prefix, bit<64> src_prefix) {
+
+        hdr.ether.etherType = ETH_P_IPV6;
+        hdr.ipv6.setValid();
+        hdr.ipv6.version = 4w6;
+        hdr.ipv6.trafficClass = 8w0;
+        hdr.ipv6.flowLabel = 20w0;
+        hdr.ipv6.payloadLen = hdr.ipv4.totalLen - 16w40;
+        hdr.ipv6.nextHdr = 8w4;
+
+        hdr.ipv6.hopLimit = hdr.ipv4.ttl;
+
+// Synthesize IPv6 SA from GTP packet
+        hdr.ipv6.srcAddr[127:64] = src_prefix;
+
+// Local SRGW Src Prefix (64)
+        hdr.ipv6.srcAddr[63:32] = hdr.ipv4.srcAddr;
+
+// IPv4 SA (32)
+        hdr.ipv6.srcAddr[31:0] = 32w0;
+
+        hdr.ipv6.dstAddr[127:96] = iw_prefix;
+
+// GTP SRv6 InterWork prefix
+        hdr.ipv6.dstAddr[95:64] = hdr.ipv4.dstAddr;
+
+        hdr.ipv6.dstAddr[63:56] = 8w0;
+
+// GTP QFI/RQI (0 for now)
+        hdr.ipv6.dstAddr[55:24] = hdr.gtpu.teid;
+        hdr.ipv6.dstAddr[23:0] = 24w0;
+
+        hdr.gtpu.setInvalid();
+        hdr.udp.setInvalid();
+        hdr.ipv4.setInvalid();
+    }
+
+    action t_m_gtp4_d(bit<32> iw_prefix, bit<64> src_prefix) {
+        t_m_gtp4_d_synthesize(iw_prefix, src_prefix);
+        cnt_srv6_t_udp.count();
+    }
+
+    action t_m_gtp4_d_sid1(bit<32> iw_prefix, bit<64> src_prefix,
+            bit<128> sid1) {
+        t_m_gtp4_d_synthesize(iw_prefix, src_prefix);
+        push_srh_sid2(hdr.ipv6.nextHdr, 1, sid1, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_udp.count();
+    }
+    action t_m_gtp4_d_sid2(bit<32> iw_prefix, bit<64> src_prefix,
+            bit<128> sid1, bit<128> sid2) {
+        t_m_gtp4_d_synthesize(iw_prefix, src_prefix);
+        push_srh_sid3(hdr.ipv6.nextHdr, 2, sid1, sid2, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_udp.count();
+    }
+    action t_m_gtp4_d_sid3(bit<32> iw_prefix, bit<64> src_prefix,
+            bit<128> sid1, bit<128> sid2, bit<128> sid3) {
+        t_m_gtp4_d_synthesize(iw_prefix, src_prefix);
+        push_srh_sid4(hdr.ipv6.nextHdr, 3, sid1, sid2, sid3, hdr.ipv6.dstAddr);
+        hdr.ipv6.nextHdr = IPPROTO_ROUTE;
+        hdr.ipv6.dstAddr = sid1;
+        cnt_srv6_t_udp.count();
+    }
+    action srv6_debug_v6() {
+
+        cnt_srv6_t_v6.count();
+    }
+    table srv6_transit_v6 {
+        key = {
+            hdr.ipv6.dstAddr: exact;
+
+        }
+        actions = {
+            @defaultonly NoAction;
+            t_insert_sid1;
+
+// T.Insert with 2 SIDs (DA + sid1)
+            t_insert_sid2;
+
+// T.Insert with 3 SIDs (DA + sid1/2)
+            t_insert_sid3;
+
+        }
+        const default_action = NoAction;
+        counters = cnt_srv6_t_v6;
+    }
+    table srv6_transit_v4 {
+        key = {
+            hdr.ipv4.dstAddr: exact;
+
+        }
+        actions = {
+            @defaultonly NoAction;
+
+        }
+        const default_action = NoAction;
+        counters = cnt_srv6_t_v4;
+    }
+    table srv6_transit_udp {
+        key = {
+            hdr.udp.dstPort : exact;
+        }
+        actions = {
+            @defaultonly NoAction;
+
+// SRv6 Mobile Userplane : draft-ietf-dmm-srv6-mobile-uplane
+            t_m_gtp4_d;
+            t_m_gtp4_d_sid1;
+
+// 2 SIDs (DA + sid1)
+            t_m_gtp4_d_sid2;
+
+// 3 SIDs (DA + sid1/2)
+            t_m_gtp4_d_sid3;
+
+// 4 SIDs (DA + sid1/2/3)
+        }
+        const default_action = NoAction;
+        counters = cnt_srv6_t_udp;
+    }
+
+    action end() {
+
+        hdr.srh.segmentsLeft = hdr.srh.segmentsLeft - 1;
+
+        hdr.ipv6.dstAddr = user_md.srv6.nextsid;
+
+    }
+    action end_m_gtp4_e() {
+        hdr.ether.etherType = ETH_P_IPV4;
+        hdr.ipv4.setValid();
+        hdr.ipv4.version = 4w4;
+        hdr.ipv4.ihl = 4w5;
+        hdr.ipv4.diffserv = 8w0;
+
+        hdr.ipv4.totalLen = hdr.ipv6.payloadLen - 16w8 - (bit<16>)hdr.srh.hdrExtLen*8 + 16w40;
+
+        hdr.ipv4.identification = 16w0;
+        hdr.ipv4.flags = 3w0;
+        hdr.ipv4.fragOffset = 13w0;
+        hdr.ipv4.ttl = hdr.ipv6.hopLimit;
+        hdr.ipv4.protocol = IPPROTO_UDP;
+
+// IPv4 header checksum will be calculated later.
+        hdr.ipv4.srcAddr = hdr.ipv6.srcAddr[63:32];
+        hdr.ipv4.dstAddr = hdr.ipv6.dstAddr[95:64];
+        hdr.udp.setValid();
+        hdr.udp.srcPort = UDP_PORT_GTPU;
+
+        hdr.udp.dstPort = UDP_PORT_GTPU;
+
+        hdr.udp.length = hdr.ipv6.payloadLen + 16w20 -16w40;
+
+        hdr.gtpu.setValid();
+        hdr.gtpu.version = 3w1;
+        hdr.gtpu.pt = 1w1;
+        hdr.gtpu.reserved = 1w0;
+        hdr.gtpu.e = 1w0;
+
+// No Extention Header
+        hdr.gtpu.s = 1w1;
+
+// YES Sequence number
+        hdr.gtpu.pn = 1w0;
+        hdr.gtpu.messageType = GTPV1_GPDU;
+
+        hdr.gtpu.messageLen = hdr.ipv6.payloadLen - 16w8 - (bit<16>)hdr.srh.hdrExtLen*8 + 16w4; 
+        hdr.gtpu.teid = hdr.ipv6.dstAddr[55:24];
+
+        hdr.gtpu.seq = 16w0;
+
+        hdr.gtpu.npdu = 8w0;
+        hdr.gtpu.nextExtHdr = 8w0;
+
+// remove IPv6/SRH headers
+        remove_srh_header();
+        hdr.ipv6.setInvalid();
+
+        cnt_srv6_e.count();
+    }
+
+    action end_am(PortId_t oif, EthernetAddress dmac) {
+
+        hdr.ipv6.dstAddr = hdr.srh_sid[0].sid;
+        hdr.ether.dstAddr = dmac;
+        egress_port = oif;
+    }
+
+    action end_am_d(PortId_t oif) {
+
+        hdr.srh.segmentsLeft = hdr.srh.segmentsLeft - 1;
+        hdr.ipv6.dstAddr = user_md.srv6.nextsid;
+        egress_port = oif;
+
+    }
+    table srv6_end {
+
+// localsid
+        key = {
+            hdr.ipv6.dstAddr : ternary;
+
+        }
+        actions = {
+            @defaultonly NoAction;
+
+// SRv6 Network Program  : draft-filsfils-spring-srv6-network-programming
+            end;
+
+
+
+// SRv6 Mobile Userplane : draft-ietf-dmm-srv6-mobile-uplane
+            end_m_gtp4_e;
+
+// End.M.GTP4.E
+
+
+// Proxy Functions : draft-xuclad-spring-sr-service-programming
+            end_am;
+        }
+        const default_action = NoAction;
+        counters = cnt_srv6_e;
+    }
+    table srv6_end_iif {
+
+// Input Interface based SRv6 End.* table
+        key = {
+            in_port : exact;
+
+        }
+        actions = {
+            @defaultonly NoAction;
+
+// Proxy Functions : draft-xuclad-spring-sr-service-programming
+            end_am_d;
+        }
+        const default_action = NoAction;
+        counters = cnt_srv6_e_iif;
+    }
+
+
+
+/*** HELPER TABLE TO SET NEXT SID */
+    action set_nextsid_1() {
+        user_md.srv6.nextsid = hdr.srh_sid[0].sid;
+    }
+    action set_nextsid_2() {
+        user_md.srv6.nextsid = hdr.srh_sid[1].sid;
+    }
+    action set_nextsid_3() {
+        user_md.srv6.nextsid = hdr.srh_sid[2].sid;
+    }
+    action set_nextsid_4() {
+        user_md.srv6.nextsid = hdr.srh_sid[3].sid;
+    }
+    table srv6_set_nextsid {
+
+// helper table
+        key = {
+            hdr.srh.segmentsLeft : exact;
+        }
+        actions = {
+            NoAction;
+            set_nextsid_1;
+            set_nextsid_2;
+            set_nextsid_3;
+            set_nextsid_4;
+        }
+        const default_action = NoAction;
+        const entries = {
+            (1) : set_nextsid_1();
+            (2) : set_nextsid_2();
+            (3) : set_nextsid_3();
+            (4) : set_nextsid_4();
+        }
+    }
+
+    action set_gtpu_type(bit<8> type) {
+        hdr.gtpu.messageType = type;
+    }
+    action set_srv6_GTPV1_END() {
+        hdr.srh.gtpMessageType = 1;
+    }
+    action set_srv6_GTPV1_ERROR() {
+        hdr.srh.gtpMessageType = 2;
+    }
+    action set_srv6_GTPV1_ECHO() {
+        hdr.srh.gtpMessageType = 4;
+    }
+    action set_srv6_GTPV1_ECHORES() {
+        hdr.srh.gtpMessageType = 8;
+    }
+    apply {
+        if (hdr.srh.isValid()) {
+            srv6_set_nextsid.apply();
+        }
+        if (hdr.ipv6.isValid()) {
+            if(!srv6_end_iif.apply().hit) {
+                if(srv6_end.apply().hit) {
+
+// draft-murakami-dmm-user-plane-message-encoding
+                    if (user_md.srv6.gtp_message_type == 1) {
+
+                        set_gtpu_type(GTPV1_END);
+                    } else if (user_md.srv6.gtp_message_type == 2) {
+                        set_gtpu_type(GTPV1_ERROR);
+                    } else if (user_md.srv6.gtp_message_type == 4) {
+                        set_gtpu_type(GTPV1_ECHO);
+                    } else if (user_md.srv6.gtp_message_type == 8) {
+                        set_gtpu_type(GTPV1_ECHORES);
+                    }
+                } else {
+                    srv6_transit_v6.apply();
+                }
+            }
+        } else if (hdr.ipv4.isValid()) {
+            if(srv6_transit_udp.apply().hit) {
+
+// Assuming this is GTP/SRv6 translation
+                if (user_md.srv6.gtpv1_type == GTPV1_END) {
+                    set_srv6_GTPV1_END();
+                } else if (user_md.srv6.gtpv1_type == GTPV1_ERROR){
+                    set_srv6_GTPV1_ERROR();
+                } else if (user_md.srv6.gtpv1_type == GTPV1_ECHO){
+                    set_srv6_GTPV1_ECHO();
+                } else if (user_md.srv6.gtpv1_type == GTPV1_ECHORES){
+                    set_srv6_GTPV1_ECHORES();
+                }
+            } else {
+                srv6_transit_v4.apply();
+            }
+        }
+    }
+}
+
+
+#endif /* _SRV6_ */
+
+
+
+
+control L2Fwd(
+    in EthernetAddress ether_dst_addr,
+    inout IngressMetadata ig_md,
+    inout PortId_t egress_port)
+    (bit<32> table_size_dmac) {
+
+    action dmac_miss() {
+
+    }
+    action dmac_hit(PortId_t port) {
+        egress_port = port;
+    }
+
+    table dmac {
+        key = {
+            ether_dst_addr : exact;
+        }
+        actions = {
+            dmac_miss;
+            dmac_hit;
+        }
+        const default_action = dmac_miss;
+        size = table_size_dmac;
+    }
+
+    apply {
+        dmac.apply();
+    }
+}
+control PortFwd(
+        in PortId_t in_port,
+        inout PortId_t egress_port) {
+
+    action set_egress_port(PortId_t port) {
+        egress_port = port;
+    }
+
+    table portfwd {
+        key = {
+            in_port : exact;
+
+// ingress phy port
+        }
+
+        actions = {
+            set_egress_port;
+        }
+    }
+
+    apply {
+        portfwd.apply();
+    }
+}
+
+
+// CONTROL: INGRESS 
+
+control SwitchIngress(
+            inout Header hdr,
+            inout UserMetadata user_md,
+            inout standard_metadata_t st_md) {
+
+
+// Instantiate controlls
+    PortFwd() port_fwd;
+    SRv6() srv6;
+    L2Fwd(1024) l2fwd;
+
+
+// Local MAC address. Apply Layer 3 tables when hit.
+    action local_mac_hit() {}
+    table local_mac {
+        key = {
+            hdr.ether.dstAddr : exact;
+        }
+        actions = {
+            NoAction;
+            local_mac_hit();
+        }
+        const default_action = NoAction;
+        size = 512;
+
+// number of Layer 3 interfaces
+    }
+
+    apply {
+
+        mark_to_drop(st_md);
+
+// set default action to drop to avoid unexpected packets going out.
+
+
+// policy L1 (port) forwarding table useful untill l2fwd is implemented.
+        port_fwd.apply(st_md.ingress_port, st_md.egress_spec);
+
+
+        srv6.apply(hdr, user_md, st_md.ingress_port, st_md.egress_spec);
+
+
+        l2fwd.apply(hdr.ether.dstAddr, user_md.ig_md, st_md.egress_spec);
+    }
+}
+
+
+
+
+// CONTROL: EGRESS 
+
+control SwitchEgress(
+            inout Header hdr,
+            inout UserMetadata user_md,
+            inout standard_metadata_t st_md) {
+
+// do nothing
+    apply { }
+}
+
+
+
+// CONTROL: CHECKSUM 
+
+control NoSwitchVerifyChecksum(
+            inout Header hdr,
+            inout UserMetadata user_md) {
+
+// dummy control to skip checkum
+    apply { }
+}
+control SwitchVerifyChecksum(
+            inout Header hdr,
+            inout UserMetadata user_md) {
+    apply {
+        verify_checksum(hdr.ipv4.isValid() && hdr.ipv4.ihl == 5,
+            { hdr.ipv4.version,
+                hdr.ipv4.ihl,
+                hdr.ipv4.diffserv,
+                hdr.ipv4.totalLen,
+                hdr.ipv4.identification,
+                hdr.ipv4.flags,
+                hdr.ipv4.fragOffset,
+                hdr.ipv4.ttl,
+                hdr.ipv4.protocol,
+                hdr.ipv4.srcAddr,
+                hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+/*****************************************************
+
+control SwitchComputeChecksum(
+            inout Header hdr,
+            inout UserMetadata user_md) {
+    apply {
+        update_checksum(hdr.ipv4.isValid() && hdr.ipv4.ihl == 5,
+            { hdr.ipv4.version,
+                hdr.ipv4.ihl,
+                hdr.ipv4.diffserv,
+                hdr.ipv4.totalLen,
+                hdr.ipv4.identification,
+                hdr.ipv4.flags,
+                hdr.ipv4.fragOffset,
+                hdr.ipv4.ttl,
+                hdr.ipv4.protocol,
+                hdr.ipv4.srcAddr,
+                hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+V1Switch(SwitchParser(),
+
+         NoSwitchVerifyChecksum(),
+         SwitchIngress(),
+         SwitchEgress(),
+         SwitchComputeChecksum(),
+
+         SwitchDeparser()) main;

individual_files/000054__raw-repositories__ElhNoah__INT.p4

@@ -0,0 +1,1277 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+#define MAX_PORTS 511
+#define CLONE_PKT 1
+
+const bit<6> HW_ID = 1;
+
+const bit<16> TYPE_IPV4 = 0x0800;
+const bit<8>  IP_PROTO_UDP = 0x11;
+const bit<8>  IP_PROTO_TCP = 0x6;
+
+const bit<6> DSCP_INT = 0x17;
+const bit<6> DSCP_MASK = 0x3F;
+
+typedef bit<48> mac_t;
+typedef bit<32> ip_address_t;
+typedef bit<16> l4_port_t;
+typedef bit<9>  port_t;
+typedef bit<32> node_id_t;
+
+const bit<32> REPORT_MIRROR_SESSION_ID = 500;
+
+
+header ethernet_t {
+    bit<48> dst_addr;
+    bit<48> src_addr;
+    bit<16> ether_type;
+}
+
+const bit<8> ETH_HEADER_LEN = 14;
+
+
+header ipv4_t {
+    bit<4>  version;
+    bit<4>  ihl;
+    bit<6>  dscp;
+    bit<2>  ecn;
+    bit<16> len;
+    bit<16> identification;
+    bit<3>  flags;
+    bit<13> frag_offset;
+    bit<8>  ttl;
+    bit<8>  protocol;
+    bit<16> hdr_checksum;
+    bit<32> src_addr;
+    bit<32> dst_addr;
+}
+
+const bit<8> IPV4_MIN_HEAD_LEN = 20;
+
+
+header udp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<16> length_;
+    bit<16> checksum;
+}
+
+const bit<8> UDP_HEADER_LEN = 8;
+
+
+header tcp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<32> seq_no;
+    bit<32> ack_no;
+    bit<4>  data_offset;
+    bit<3>  res;
+    bit<3>  ecn;
+    bit<6>  ctrl;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgent_ptr;
+}
+
+const bit<8> TCP_HEADER_LEN = 20;
+
+
+
+// INT shim header for INT over TCP/UDP
+header intl4_shim_t {
+    bit<4> int_type;
+
+// Type of INT Header
+    bit<2> npt;
+
+// Next protocol type
+    bit<2> rsvd1;
+
+// Reserved
+    bit<8> len;
+
+// Length of INT Metadata header and INT stack in 4-byte words, not including the shim header (1 word)
+    bit<8> rsvd2;
+
+// Reserved
+    bit<6> original_dscp;
+
+// Original DSCP value
+    bit<2> rsvd3;
+
+// Reserved
+}
+
+const bit<16> INT_SHIM_HEADER_SIZE = 4;
+
+
+// INT header
+header int_header_t {
+    bit<4>   ver;
+
+// Version
+    bit<1>   d;
+
+// Discard
+    bit<1>   e;
+    bit<1>   m;
+    bit<12>  rsvd1;
+    bit<5>   hop_metadata_len;
+    bit<8>   remaining_hop_cnt;
+    bit<4>   instruction_mask_0003;
+
+// Split the bits for lookup
+    bit<4>   instruction_mask_0407;
+    bit<4>   instruction_mask_0811;
+    bit<4>   instruction_mask_1215;
+    bit<16>  domain_specific_id;
+
+// Unique INT Domain ID
+    bit<16>  ds_instruction;
+
+// Instruction bitmap specific to the INT Domain identified by the Domain specific ID
+    bit<16>  ds_flags;
+
+// Domain specific flags
+}
+
+const bit<16> INT_HEADER_SIZE = 12;
+const bit<8> INT_HEADER_WORD = 3;
+const bit<16> INT_TOTAL_HEADER_SIZE = INT_HEADER_SIZE + INT_SHIM_HEADER_SIZE;
+
+
+
+// INT meta-value headers - different header for each value type to monitor
+header int_node_id_t {
+    bit<32> node_id;
+}
+header int_level1_port_ids_t {
+    bit<16> ingress_port_id;
+    bit<16> egress_port_id;
+}
+header int_hop_latency_t {
+    bit<32> hop_latency;
+}
+header int_q_occupancy_t {
+    bit<8> q_id;
+    bit<24> q_occupancy;
+}
+header int_ingress_tstamp_t {
+    bit<64> ingress_tstamp;
+}
+header int_egress_tstamp_t {
+    bit<64> egress_tstamp;
+}
+header int_level2_port_ids_t {
+    bit<32> ingress_port_id;
+    bit<32> egress_port_id;
+}
+
+
+// These two are not implemented yet
+header int_egress_port_tx_util_t {
+    bit<32> egress_port_tx_util;
+
+// This is used but the queue latency is gathered instead
+}
+
+header int_buffer_t {
+    bit<8> buffer_id;
+    bit<24> buffer_occupancy;
+}
+
+header int_data_t {
+
+    varbit<1920> data;
+}
+
+
+// Report Telemetry Headers - Group Header
+header report_group_header_t {
+    bit<4>  ver;
+    bit<6>  hw_id;
+    bit<22> seq_no;
+    bit<32> node_id;
+}
+const bit<8> REPORT_GROUP_HEADER_LEN = 8;
+
+
+// Report Telemetry Headers - Individual Header
+header report_individual_header_t {
+    bit<4>  rep_type;
+    bit<4>  in_type;
+    bit<8>  len;
+    bit<8>  rep_md_len;
+    bit<1>  d;
+    bit<1>  q;
+    bit<1>  f;
+    bit<1>  i;
+    bit<4>  rsvd;
+
+    bit<16> rep_md_bits;
+    bit<16> domain_specific_id;
+    bit<16> domain_specific_md_bits;
+    bit<16> domain_specific_md_status;
+}
+const bit<8> REPORT_INDIVIDUAL_HEADER_LEN = 12;
+
+
+// Preserving metadata header for the cloned packet
+struct preserving_metadata_t {
+    @field_list(1)
+    bit<9> ingress_port;
+    @field_list(1)
+    bit<9> egress_port;
+    @field_list(1)
+    bit<32> deq_timedelta;
+    @field_list(1)
+    bit<19> deq_qdepth;
+    @field_list(1)
+    bit<48> ingress_global_timestamp;
+    @field_list(1)
+    bit<48> egress_global_timestamp;
+}
+
+struct headers {
+
+
+// Original Packet Headers
+    ethernet_t                  ethernet;
+    ipv4_t			            ipv4;
+    udp_t			            udp;
+    tcp_t			            tcp;
+
+
+// INT Report Encapsulation
+    ethernet_t                  report_ethernet;
+    ipv4_t                      report_ipv4;
+    udp_t                       report_udp;
+
+
+// INT Headers
+    int_header_t                int_header;
+    intl4_shim_t                intl4_shim;
+
+
+//INT Metadata
+    int_data_t                  int_data;
+    int_node_id_t               int_node_id;
+    int_level1_port_ids_t       int_level1_port_ids;
+    int_hop_latency_t           int_hop_latency;
+    int_q_occupancy_t           int_q_occupancy;
+    int_ingress_tstamp_t        int_ingress_tstamp;
+    int_egress_tstamp_t         int_egress_tstamp;
+    int_level2_port_ids_t       int_level2_port_ids;
+    int_egress_port_tx_util_t   int_egress_tx_util;
+
+
+// INT Report Headers
+    report_group_header_t       report_group_header;
+    report_individual_header_t  report_individual_header;
+}
+
+struct int_metadata_t {
+    node_id_t node_id;
+    bit<16> new_bytes;
+    bit<8>  new_words;
+    bool  source;
+    bool  sink;
+    bit<8> intl4_shim_len;
+}
+
+struct local_metadata_t {
+    bit<16>       l4_src_port;
+    bit<16>       l4_dst_port;
+    int_metadata_t int_meta;
+    preserving_metadata_t perserv_meta;
+}
+
+
+
+parser MyParser( packet_in packet,
+                        out headers hdr,
+                        inout local_metadata_t local_metadata,
+                        inout standard_metadata_t standard_metadata) {
+
+    state start {
+        transition parse_ethernet;
+    }
+
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.ether_type) {
+            TYPE_IPV4: parse_ipv4;
+            default: accept;
+        }
+    }
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            IP_PROTO_UDP: parse_udp;
+            IP_PROTO_TCP: parse_tcp;
+            default: accept;
+        }
+    }
+
+    state parse_udp {
+        packet.extract(hdr.udp);
+        local_metadata.l4_src_port = hdr.udp.src_port;
+        local_metadata.l4_dst_port = hdr.udp.dst_port;
+        transition select(hdr.ipv4.dscp) {
+            DSCP_INT &&& DSCP_MASK: parse_shim;
+            default:  accept;
+        }
+    }
+
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        local_metadata.l4_src_port = hdr.tcp.src_port;
+        local_metadata.l4_dst_port = hdr.tcp.dst_port;
+        transition select(hdr.ipv4.dscp) {
+            DSCP_INT &&& DSCP_MASK: parse_shim;
+            default:  accept;
+        }
+    }
+
+    state parse_shim {
+        packet.extract(hdr.intl4_shim);
+        local_metadata.int_meta.intl4_shim_len = hdr.intl4_shim.len;
+        transition parse_int_hdr;
+    }
+
+    state parse_int_hdr {
+        packet.extract(hdr.int_header);
+        transition parse_int_data;
+    }
+
+    state parse_int_data {
+        packet.extract(hdr.int_data, ((bit<32>) (local_metadata.int_meta.intl4_shim_len - INT_HEADER_WORD)) << 5);
+        transition accept;
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, 
+                         in headers hdr) {
+
+    apply {
+
+        packet.emit(hdr.report_ethernet);
+        packet.emit(hdr.report_ipv4);
+        packet.emit(hdr.report_udp);
+
+        packet.emit(hdr.report_group_header);
+        packet.emit(hdr.report_individual_header);
+
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.udp);
+        packet.emit(hdr.tcp);
+
+        packet.emit(hdr.intl4_shim);
+        packet.emit(hdr.int_header);
+
+        packet.emit(hdr.int_node_id);
+        packet.emit(hdr.int_level1_port_ids);
+        packet.emit(hdr.int_hop_latency);
+        packet.emit(hdr.int_q_occupancy);
+        packet.emit(hdr.int_ingress_tstamp);
+        packet.emit(hdr.int_egress_tstamp);
+        packet.emit(hdr.int_level2_port_ids);
+        packet.emit(hdr.int_egress_tx_util);
+
+        packet.emit(hdr.int_data);        
+    }
+}
+
+control MyVerifyChecksum(inout headers hdr, inout local_metadata_t local_metadata) {
+    apply {
+        verify_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.dscp,
+              hdr.ipv4.ecn,
+              hdr.ipv4.len,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.frag_offset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.src_addr,
+              hdr.ipv4.dst_addr },
+            hdr.ipv4.hdr_checksum,
+            HashAlgorithm.csum16
+        );
+     }
+}
+
+control MyComputeChecksum(inout headers hdr, inout local_metadata_t local_metadata){
+    apply{
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.dscp,
+              hdr.ipv4.ecn,
+              hdr.ipv4.len,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.frag_offset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.src_addr,
+              hdr.ipv4.dst_addr },
+            hdr.ipv4.hdr_checksum,
+            HashAlgorithm.csum16
+        );
+
+    }
+    
+}
+
+control process_int_sink (
+    inout headers hdr) {
+    
+    action restore_header () {
+        hdr.ipv4.dscp = hdr.intl4_shim.original_dscp;
+        bit<16> len_bytes = (((bit<16>)hdr.intl4_shim.len) << 2) + INT_SHIM_HEADER_SIZE;
+        hdr.ipv4.len = hdr.ipv4.len - len_bytes;
+        if(hdr.udp.isValid()) {
+            hdr.udp.length_ = hdr.udp.length_ - len_bytes;
+        }
+    }
+
+    
+    action int_sink() {
+
+// remove all the INT information from the packet
+        hdr.intl4_shim.setInvalid();
+        hdr.int_header.setInvalid();
+        hdr.int_node_id.setInvalid();
+        hdr.int_level1_port_ids.setInvalid();
+        hdr.int_hop_latency.setInvalid();
+        hdr.int_q_occupancy.setInvalid();
+        hdr.int_ingress_tstamp.setInvalid();
+        hdr.int_egress_tstamp.setInvalid();
+        hdr.int_level2_port_ids.setInvalid();
+        hdr.int_egress_tx_util.setInvalid();
+        hdr.int_data.setInvalid();
+    }
+
+    apply {
+        restore_header();
+        int_sink();
+    }
+}
+
+
+// Action for the INT telemetry report, as it is encapsulated with new Ethernet, IP and UDP headers
+control process_int_report (inout headers hdr,
+                            inout local_metadata_t local_metadata,
+                            inout standard_metadata_t standard_metadata) {
+
+
+// Register for sequence number
+    register<bit<22>>(1) seq_number;
+
+    action increment_counter() {
+        bit<22> tmp;
+        seq_number.read(tmp, 0);
+        tmp = tmp + 1;
+        seq_number.write(0, tmp);
+    }
+
+    action do_report_encapsulation(mac_t src_mac,
+                                mac_t mon_mac, 
+                                ip_address_t src_ip,
+                                ip_address_t mon_ip, 
+                                l4_port_t src_port, 
+                                l4_port_t mon_port) {
+                                
+
+// Report Ethernet Header
+        hdr.report_ethernet.setValid();
+        hdr.report_ethernet.dst_addr = mon_mac;
+        hdr.report_ethernet.src_addr = src_mac;
+        hdr.report_ethernet.ether_type = 0x0800;
+
+
+// Report IPV4 Header
+        hdr.report_ipv4.setValid();
+        hdr.report_ipv4.version = 4w4;
+        hdr.report_ipv4.ihl = 4w5;
+        hdr.report_ipv4.dscp = 6w0;
+        hdr.report_ipv4.ecn = 2w0;
+
+        if (hdr.udp.isValid()) {
+            hdr.report_ipv4.len = (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + 
+            local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2);
+        } else if (hdr.tcp.isValid()) {
+            hdr.report_ipv4.len = (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + 
+            local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) TCP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2);
+        }
+
+        hdr.report_ipv4.identification = 0;
+        hdr.report_ipv4.flags = 0;
+        hdr.report_ipv4.frag_offset = 0;
+        hdr.report_ipv4.ttl = 64;
+        hdr.report_ipv4.protocol = IP_PROTO_UDP;
+        hdr.report_ipv4.src_addr = src_ip;
+        hdr.report_ipv4.dst_addr = mon_ip;
+
+
+//Report UDP Header
+        hdr.report_udp.setValid();
+        hdr.report_udp.src_port = src_port;
+        hdr.report_udp.dst_port = mon_port;
+        
+        if (hdr.udp.isValid()) {
+            hdr.report_udp.length_ = (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + 
+            local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2);
+        } else if (hdr.tcp.isValid()) {
+            hdr.report_udp.length_ = (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + 
+            local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) TCP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2);
+        }
+
+
+// Telemetry Group Header
+        hdr.report_group_header.setValid();
+        hdr.report_group_header.ver = 2;
+
+// Version 2.0
+        hdr.report_group_header.hw_id = HW_ID;
+
+// Default Value 1
+        seq_number.read(hdr.report_group_header.seq_no, 0);
+        increment_counter();
+        hdr.report_group_header.node_id = local_metadata.int_meta.node_id;
+        
+        
+
+// Telemetry Report Individual Header
+        hdr.report_individual_header.setValid();
+        hdr.report_individual_header.rep_type = 1;
+
+// INT Report
+        hdr.report_individual_header.in_type = 4;
+
+// Individual Report Inner Content is an IPv4 packet
+        if (hdr.udp.isValid()) {
+            hdr.report_individual_header.len = 2 + local_metadata.int_meta.new_words + 5 + 2 + 4;
+        } else if (hdr.tcp.isValid()) {
+            hdr.report_individual_header.len = 2 + local_metadata.int_meta.new_words + 5 + 5 + 4;
+        }
+        hdr.report_individual_header.rep_md_len = local_metadata.int_meta.new_words;
+        hdr.report_individual_header.d = 0;
+        hdr.report_individual_header.q = 0;
+        hdr.report_individual_header.f = 1;
+        hdr.report_individual_header.i = 0;
+        hdr.report_individual_header.rsvd = 0;
+
+
+// Individual report main contents
+        hdr.report_individual_header.rep_md_bits = hdr.int_header.instruction_mask_0003 ++ hdr.int_header.instruction_mask_0407 ++ 
+                                                    hdr.int_header.instruction_mask_0811 ++ hdr.int_header.instruction_mask_1215;
+        hdr.report_individual_header.domain_specific_id = 0;
+        hdr.report_individual_header.domain_specific_md_bits = 0;
+        hdr.report_individual_header.domain_specific_md_status = 0;
+
+        hdr.ethernet.setInvalid();
+    }
+
+    table tb_generate_report {
+        actions = {
+            do_report_encapsulation;
+            NoAction();
+        }
+        default_action = do_report_encapsulation(0, 0, 0, 0, 0, 0);
+    }
+
+    apply {
+        tb_generate_report.apply();
+    }
+}
+
+control process_int_transit (
+    inout headers hdr,
+    inout local_metadata_t local_metadata,
+    inout standard_metadata_t standard_metadata) {
+
+    action init_metadata(node_id_t node_id) {
+        local_metadata.int_meta.node_id = node_id;
+    }
+
+
+// Node ID
+    action int_set_header_0() { 
+        hdr.int_node_id.setValid();
+        hdr.int_node_id.node_id = local_metadata.int_meta.node_id;
+    }
+    
+
+// Level 1 ingress interface ID + Egress interface ID
+    action int_set_header_1() { 
+        hdr.int_level1_port_ids.setValid();
+        hdr.int_level1_port_ids.ingress_port_id = (bit<16>) standard_metadata.ingress_port;
+        hdr.int_level1_port_ids.egress_port_id = (bit<16>) standard_metadata.egress_port;
+    }
+    
+
+// Hop latency
+    action int_set_header_2() { 
+        hdr.int_hop_latency.setValid();
+        hdr.int_hop_latency.hop_latency = (bit<32>) standard_metadata.egress_global_timestamp - (bit<32>) standard_metadata.ingress_global_timestamp;
+    }
+    
+
+// Queue ID and queue occupancy
+    action int_set_header_3() { 
+        hdr.int_q_occupancy.setValid();
+
+        hdr.int_q_occupancy.q_id = 0;
+        hdr.int_q_occupancy.q_occupancy = (bit<24>) standard_metadata.deq_qdepth;
+    }
+    
+
+// Ingress timestamp
+    action int_set_header_4() { 
+        hdr.int_ingress_tstamp.setValid();
+        hdr.int_ingress_tstamp.ingress_tstamp = (bit<64>) standard_metadata.ingress_global_timestamp;
+    }
+    
+
+// Egress timestamp
+    action int_set_header_5() { 
+        hdr.int_egress_tstamp.setValid();
+        hdr.int_egress_tstamp.egress_tstamp = (bit<64>) standard_metadata.egress_global_timestamp;
+    }
+    
+
+// Level 2 Ingress Interface ID + Egress Interface ID
+    action int_set_header_6() {  
+        hdr.int_level2_port_ids.setValid();
+        hdr.int_level2_port_ids.ingress_port_id = (bit<32>) local_metadata.l4_src_port;
+        hdr.int_level2_port_ids.egress_port_id = (bit<32>) local_metadata.l4_dst_port;
+     }
+    
+
+// Egress interface TX utilization
+    action int_set_header_7() { 
+        hdr.int_egress_tx_util.setValid();
+        hdr.int_egress_tx_util.egress_port_tx_util = (bit<32>) standard_metadata.deq_timedelta;
+    }
+
+
+// Actions to keep track of the new metadata added
+    action add_1() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 1;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 4;
+    }
+
+    
+    action add_2() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 2;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 8;
+    }
+
+    
+    action add_3() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 3;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 12;
+    }
+
+    
+    action add_4() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 4;
+       local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 16;
+    }
+
+    
+    action add_5() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 5;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 20;
+    }
+
+    action add_6() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 6;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 24;
+    }
+
+    action add_7() {
+        local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 7;
+        local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 28;
+    }
+
+
+// Action to process instruction bits 0-3
+    action int_set_header_0003_i0() {
+    }
+    
+    action int_set_header_0003_i1() {
+        int_set_header_3();
+        add_1();
+    }
+    
+    action int_set_header_0003_i2() {
+        int_set_header_2();
+        add_1();
+    }
+    
+    action int_set_header_0003_i3() {
+        int_set_header_3();
+        int_set_header_2();
+        add_2();
+    }
+    
+    action int_set_header_0003_i4() {
+        int_set_header_1();
+        add_1();
+    }
+    
+    action int_set_header_0003_i5() {
+        int_set_header_3();
+        int_set_header_1();
+        add_2();
+    }
+    
+    action int_set_header_0003_i6() {
+        int_set_header_2();
+        int_set_header_1();
+        add_2();
+    }
+    
+    action int_set_header_0003_i7() {
+        int_set_header_3();
+        int_set_header_2();
+        int_set_header_1();
+        add_3();
+    }
+    
+    action int_set_header_0003_i8() {
+        int_set_header_0();
+        add_1();
+    }
+    
+    action int_set_header_0003_i9() {
+        int_set_header_3();
+        int_set_header_0();
+        add_2();
+    }
+    
+    action int_set_header_0003_i10() {
+        int_set_header_2();
+        int_set_header_0();
+        add_2();
+    }
+    
+    action int_set_header_0003_i11() {
+        int_set_header_3();
+        int_set_header_2();
+        int_set_header_0();
+        add_3();
+    }
+    
+    action int_set_header_0003_i12() {
+        int_set_header_1();
+        int_set_header_0();
+        add_2();
+    }
+    
+    action int_set_header_0003_i13() {
+        int_set_header_3();
+        int_set_header_1();
+        int_set_header_0();
+        add_3();
+    }
+    
+    action int_set_header_0003_i14() {
+        int_set_header_2();
+        int_set_header_1();
+        int_set_header_0();
+        add_3();
+    }
+    
+    action int_set_header_0003_i15() {
+        int_set_header_3();
+        int_set_header_2();
+        int_set_header_1();
+        int_set_header_0();
+        add_4();
+    }
+
+
+// Action to process instruction bits 4-7
+    action int_set_header_0407_i0() {
+    }
+    
+    action int_set_header_0407_i1() {
+        int_set_header_7();
+        add_1();
+    }
+    
+    action int_set_header_0407_i2() {
+        int_set_header_6();
+        add_2();
+    }
+    
+    action int_set_header_0407_i3() {
+        int_set_header_7();
+        int_set_header_6();
+        add_3();
+    }
+    
+    action int_set_header_0407_i4() {
+        int_set_header_5();
+        add_2();
+    }
+    
+    action int_set_header_0407_i5() {
+        int_set_header_7();
+        int_set_header_5();
+        add_3();
+    }
+    
+    action int_set_header_0407_i6() {
+        int_set_header_6();
+        int_set_header_5();
+        add_4();
+    }
+    
+    action int_set_header_0407_i7() {
+        int_set_header_7();
+        int_set_header_6();
+        int_set_header_5();
+        add_5();
+    }
+    
+    action int_set_header_0407_i8() {
+        int_set_header_4();
+        add_2();
+    }
+    
+    action int_set_header_0407_i9() {
+        int_set_header_7();
+        int_set_header_4();
+        add_3();
+    }
+    
+    action int_set_header_0407_i10() {
+        int_set_header_6();
+        int_set_header_4();
+        add_4();
+    }
+    
+    action int_set_header_0407_i11() {
+        int_set_header_7();
+        int_set_header_6();
+        int_set_header_4();
+        add_5();
+    }
+    
+    action int_set_header_0407_i12() {
+        int_set_header_5();
+        int_set_header_4();
+        add_4();
+    }
+    
+    action int_set_header_0407_i13() {
+        int_set_header_7();
+        int_set_header_5();
+        int_set_header_4();
+        add_5();
+    }
+    
+    action int_set_header_0407_i14() {
+        int_set_header_6();
+        int_set_header_5();
+        int_set_header_4();
+        add_6();
+    }
+    
+    action int_set_header_0407_i15() {
+        int_set_header_7();
+        int_set_header_6();
+        int_set_header_5();
+        int_set_header_4();
+        add_7();
+    }
+
+
+// Default action used to set node ID.
+    table tb_int_insert {
+        actions = {
+            init_metadata;
+            NoAction;
+        }
+        default_action = init_metadata(0);
+        size = 1;
+    }
+
+
+// Table to process instruction bits 0-3
+    table tb_int_inst_0003 {
+        key = {
+            hdr.int_header.instruction_mask_0003 : exact;
+        }
+        actions = {
+            int_set_header_0003_i0;
+            int_set_header_0003_i1;
+            int_set_header_0003_i2;
+            int_set_header_0003_i3;
+            int_set_header_0003_i4;
+            int_set_header_0003_i5;
+            int_set_header_0003_i6;
+            int_set_header_0003_i7;
+            int_set_header_0003_i8;
+            int_set_header_0003_i9;
+            int_set_header_0003_i10;
+            int_set_header_0003_i11;
+            int_set_header_0003_i12;
+            int_set_header_0003_i13;
+            int_set_header_0003_i14;
+            int_set_header_0003_i15;
+        }
+        
+        const entries = {
+            (0x0) : int_set_header_0003_i0();
+            (0x1) : int_set_header_0003_i1();
+            (0x2) : int_set_header_0003_i2();
+            (0x3) : int_set_header_0003_i3();
+            (0x4) : int_set_header_0003_i4();
+            (0x5) : int_set_header_0003_i5();
+            (0x6) : int_set_header_0003_i6();
+            (0x7) : int_set_header_0003_i7();
+            (0x8) : int_set_header_0003_i8();
+            (0x9) : int_set_header_0003_i9();
+            (0xA) : int_set_header_0003_i10();
+            (0xB) : int_set_header_0003_i11();
+            (0xC) : int_set_header_0003_i12();
+            (0xD) : int_set_header_0003_i13();
+            (0xE) : int_set_header_0003_i14();
+            (0xF) : int_set_header_0003_i15();
+        }
+    }
+
+
+// Table to process instruction bits 4-7
+    table tb_int_inst_0407 {
+        key = {
+            hdr.int_header.instruction_mask_0407 : exact;
+        }
+        actions = {
+            int_set_header_0407_i0;
+            int_set_header_0407_i1;
+            int_set_header_0407_i2;
+            int_set_header_0407_i3;
+            int_set_header_0407_i4;
+            int_set_header_0407_i5;
+            int_set_header_0407_i6;
+            int_set_header_0407_i7;
+            int_set_header_0407_i8;
+            int_set_header_0407_i9;
+            int_set_header_0407_i10;
+            int_set_header_0407_i11;
+            int_set_header_0407_i12;
+            int_set_header_0407_i13;
+            int_set_header_0407_i14;
+            int_set_header_0407_i15;
+        }
+        
+        const entries = {
+            (0x0) : int_set_header_0407_i0();
+            (0x1) : int_set_header_0407_i1();
+            (0x2) : int_set_header_0407_i2();
+            (0x3) : int_set_header_0407_i3();
+            (0x4) : int_set_header_0407_i4();
+            (0x5) : int_set_header_0407_i5();
+            (0x6) : int_set_header_0407_i6();
+            (0x7) : int_set_header_0407_i7();
+            (0x8) : int_set_header_0407_i8();
+            (0x9) : int_set_header_0407_i9();
+            (0xA) : int_set_header_0407_i10();
+            (0xB) : int_set_header_0407_i11();
+            (0xC) : int_set_header_0407_i12();
+            (0xD) : int_set_header_0407_i13();
+            (0xE) : int_set_header_0407_i14();
+            (0xF) : int_set_header_0407_i15();
+        }
+    }
+
+    apply {
+        tb_int_insert.apply();
+
+        tb_int_inst_0003.apply();
+        tb_int_inst_0407.apply();
+
+
+// Decrement remaining hop cnt
+        hdr.int_header.remaining_hop_cnt = hdr.int_header.remaining_hop_cnt - 1;
+
+
+// Update headers lengths.
+        if (hdr.ipv4.isValid()) {
+            hdr.ipv4.len = hdr.ipv4.len + local_metadata.int_meta.new_bytes;
+        }
+        if (hdr.udp.isValid()) {
+            hdr.udp.length_ = hdr.udp.length_ + local_metadata.int_meta.new_bytes;
+        }
+        if (hdr.intl4_shim.isValid()) {
+            hdr.intl4_shim.len = hdr.intl4_shim.len + local_metadata.int_meta.new_words;
+        }
+    }
+}
+
+control process_int_source_sink (
+    inout headers hdr,
+    inout local_metadata_t local_metadata,
+    inout standard_metadata_t standard_metadata) {
+
+    action int_set_source () {
+        local_metadata.int_meta.source = true;
+    }
+
+    action int_set_sink () {
+        local_metadata.int_meta.sink = true;
+    }
+
+    table tb_set_source {
+        key = {
+            standard_metadata.ingress_port: exact;
+        }
+        actions = {
+            int_set_source;
+            NoAction();
+        }
+        const default_action = NoAction();
+        size = MAX_PORTS;
+    }
+    
+    table tb_set_sink {
+        key = {
+            standard_metadata.egress_port: exact;   
+        }
+        actions = {
+            int_set_sink;
+            NoAction();
+        }
+        const default_action = NoAction();
+        size = MAX_PORTS;
+    }
+
+    apply {
+        tb_set_source.apply();
+        tb_set_sink.apply();
+    }
+}
+
+
+// Insert INT header to the packet
+control process_int_source (
+    inout headers hdr,
+    inout local_metadata_t local_metadata) {
+
+    action int_source(bit<5> hop_metadata_len, bit<8> remaining_hop_cnt, bit<4> ins_mask0003, bit<4> ins_mask0407) {
+        
+        hdr.intl4_shim.setValid();
+
+// insert INT shim header
+        hdr.intl4_shim.int_type = 1;
+
+// INT type: MD-type (1) , destination type (2), MX-type (3)
+        hdr.intl4_shim.npt = 0;
+
+// next protocol type: 0
+        hdr.intl4_shim.len = 3;
+
+        hdr.intl4_shim.original_dscp = hdr.ipv4.dscp;
+
+// original DSCP
+        
+
+// insert INT header
+        hdr.int_header.setValid();
+        hdr.int_header.ver = 2;
+
+// INT 2.1
+        hdr.int_header.d = 0;
+        hdr.int_header.hop_metadata_len = hop_metadata_len;
+        hdr.int_header.remaining_hop_cnt = remaining_hop_cnt;
+        hdr.int_header.instruction_mask_0003 = ins_mask0003;
+        hdr.int_header.instruction_mask_0407 = ins_mask0407;
+        hdr.int_header.instruction_mask_0811 = 0;
+
+// bit 8 is buffer related (not yet implemented), rest are reserved
+        hdr.int_header.instruction_mask_1215 = 0;
+
+// reserved
+
+        hdr.int_header.domain_specific_id = 0;
+
+// Unique INT Domain ID (not yet implemented)
+        hdr.int_header.ds_instruction = 0;
+
+// Instruction bitmap specific to the INT Domain identified by the Domain specific ID (not yet implemented)
+        hdr.int_header.ds_flags = 0;
+
+// Domain specific flags (not yet implemented)
+
+
+// add the header len (3 words) to total len
+        hdr.ipv4.len = hdr.ipv4.len + INT_TOTAL_HEADER_SIZE;
+        if(hdr.udp.isValid()) {
+            hdr.udp.length_ = hdr.udp.length_ + INT_TOTAL_HEADER_SIZE;
+        }
+
+        hdr.ipv4.dscp = DSCP_INT;
+    }
+
+    table tb_int_source {
+        key = {
+
+            hdr.ipv4.dst_addr: lpm;
+        }
+        actions = {
+            int_source;
+            NoAction;
+        }
+        const default_action = NoAction();
+    }
+
+    apply {
+        tb_int_source.apply();
+    }
+}
+
+control l3_forward(inout headers hdr,
+                       inout local_metadata_t local_metadata,
+                       inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action ipv4_forward(mac_t dstAddr, mac_t srcAddr, port_t port) {
+        standard_metadata.egress_spec = port;
+        standard_metadata.egress_port = port;
+        hdr.ethernet.src_addr = srcAddr;
+        hdr.ethernet.dst_addr = dstAddr;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+    }   
+
+    table ipv4_lpm {
+        key = {
+            hdr.ipv4.dst_addr : lpm;
+        }
+        actions = {
+            ipv4_forward;
+            drop;
+        }
+        size = 1024;
+        const default_action = drop();
+    }
+
+    apply {
+        if(hdr.ipv4.ttl == 0) {
+            drop();
+        }
+        if(hdr.ipv4.isValid()) {
+            ipv4_lpm.apply();
+        }
+            
+    }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout local_metadata_t local_metadata,
+                  inout standard_metadata_t standard_metadata) {
+    
+    apply {
+        if(hdr.ipv4.isValid()) {
+
+
+// Perform L2 forwarding based on IPv4 destination address
+            l3_forward.apply(hdr, local_metadata, standard_metadata);
+
+            if (hdr.udp.isValid() || hdr.tcp.isValid()) {
+
+
+// Setting source and sink local metadata
+                process_int_source_sink.apply(hdr, local_metadata, standard_metadata);
+
+
+// In case of source add the INT header
+                if (local_metadata.int_meta.source == true) {
+                    process_int_source.apply(hdr, local_metadata);
+                }
+
+
+// Clone packet for Telemetry Report
+                if (local_metadata.int_meta.sink == true && hdr.int_header.isValid()) {
+                    local_metadata.perserv_meta.ingress_port = standard_metadata.ingress_port;
+                    local_metadata.perserv_meta.egress_port = standard_metadata.egress_port;
+                    local_metadata.perserv_meta.deq_qdepth = standard_metadata.deq_qdepth;
+                    local_metadata.perserv_meta.deq_timedelta = standard_metadata.deq_timedelta;
+                    local_metadata.perserv_meta.ingress_global_timestamp = standard_metadata.ingress_global_timestamp;
+                    local_metadata.perserv_meta.egress_global_timestamp = standard_metadata.egress_global_timestamp;
+                    clone_preserving_field_list(CloneType.I2E, REPORT_MIRROR_SESSION_ID, 1);
+
+                }
+            }
+        }
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout local_metadata_t local_metadata,
+                 inout standard_metadata_t standard_metadata) {
+    
+    apply {
+
+// Insert old packet metadata into the cloned packet
+        if(hdr.int_header.isValid() && standard_metadata.instance_type == CLONE_PKT) {
+            standard_metadata.ingress_port = local_metadata.perserv_meta.ingress_port;
+            standard_metadata.egress_port = local_metadata.perserv_meta.egress_port;
+            standard_metadata.deq_qdepth = local_metadata.perserv_meta.deq_qdepth;
+            standard_metadata.deq_timedelta = local_metadata.perserv_meta.deq_timedelta;
+            standard_metadata.ingress_global_timestamp = local_metadata.perserv_meta.ingress_global_timestamp;
+            standard_metadata.egress_global_timestamp = local_metadata.perserv_meta.egress_global_timestamp;
+        }
+
+        process_int_transit.apply(hdr, local_metadata, standard_metadata);
+
+
+// In case of cloned packet, send telemetry report
+        if (standard_metadata.instance_type == CLONE_PKT) {
+            process_int_report.apply(hdr, local_metadata, standard_metadata);
+        }
+
+
+// In case of sink, remove INT header from original packet
+        if (hdr.int_header.isValid() && local_metadata.int_meta.sink == true && standard_metadata.instance_type != CLONE_PKT) {
+            process_int_sink.apply(hdr);
+        }
+    }
+}
+
+
+
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000055__raw-repositories__felipejrampazzo__Projeto-IA376C.p4

@@ -0,0 +1,618 @@
+
+#include <core.p4>
+#include <v1model.p4>
+
+#define DIMENSION 4
+
+register<bit<32>>(20) register_pub_matrix;
+register<bit<32>>(10) register_secret_vector;
+register<bit<32>>(10) register_noise_vector;
+register<bit<32>>(10) register_public_vector;
+register<bit<32>>(36) register_public_vector_full;
+register<bit<32>>(18) register_mod_public_vector;
+register <bit<32>>(4) register_seed;
+
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+
+const bit<16> P4CALC_ETYPE = 0x1234;
+const bit<8>  P4CALC_P     = 0x4B;
+
+// K - KYBER
+const bit<8>  GEN  = 0x47;
+
+// 'G'
+const bit<8>  ENC = 0x45;
+
+// 'E'
+const bit<8>  DEC   = 0x44;
+
+// 'D'
+const bit<32> PARAM_Q = 3329;
+
+header p4calc_t {
+    bit<8>  p;
+    bit<8>  op;
+
+    bit<32> t_0;
+    bit<32> t_1;
+    bit<32> t_2;
+    bit<32> t_3;
+    bit<32> t_4;
+    bit<32> t_5;
+    bit<32> t_6;
+    bit<32> t_7;
+    bit<32> t_8;
+    bit<32> t_9;
+    
+    bit<32> seed;
+}
+
+
+struct headers {
+    ethernet_t   ethernet;
+    p4calc_t     p4calc;
+}
+
+
+struct metadata {
+
+/* In our case it is empty */
+}
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            P4CALC_ETYPE : check_p4calc;
+            default      : accept;
+        }
+    }
+
+    state check_p4calc {
+        transition select(packet.lookahead<p4calc_t>().p) {
+            (P4CALC_P) : parse_p4calc;
+            default    : accept;
+        }
+    }
+
+    state parse_p4calc {
+        packet.extract(hdr.p4calc);
+        transition accept;
+    }
+}
+
+
+control MyVerifyChecksum(inout headers hdr,
+                         inout metadata meta) {
+    apply { }
+}
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action send_back() {
+        bit<48> tmp;
+        
+        tmp = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = hdr.ethernet.srcAddr;
+        hdr.ethernet.srcAddr = tmp;
+
+
+/* Send the packet back to the port it came from */
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+    }
+
+    #define gen_matrix(INDEX, ROUND) action gen_matrix_i##INDEX##_r##ROUND##() { \
+        bit<32> coef;                                                            \
+        register_seed.read(coef, 0);                                             \
+        hash(coef, HashAlgorithm.crc32, (bit<32>) 0, {coef}, (bit<32>) PARAM_Q); \
+        register_pub_matrix.write(##INDEX##, coef);                              \
+        register_seed.write(0, coef);                                            \
+    }
+    gen_matrix(0, 1)
+    gen_matrix(1, 1)
+    gen_matrix(2, 1)
+    gen_matrix(3, 1)
+    gen_matrix(4, 1)
+    gen_matrix(5, 1)
+    gen_matrix(6, 1)
+    gen_matrix(7, 1)
+    gen_matrix(8, 1)
+    gen_matrix(9, 1)
+    gen_matrix(10, 1)
+    gen_matrix(11, 1)
+    gen_matrix(12, 1)
+    gen_matrix(13, 1)
+    gen_matrix(14, 1)
+    gen_matrix(15, 1)
+    gen_matrix(16, 1)
+    gen_matrix(17, 1)
+    gen_matrix(18, 1)
+    gen_matrix(19, 1)
+      
+
+    #define gen_secret_vector(INDEX) action gen_secret_vector_i##INDEX##() { \
+        bit<32> coef; \
+        random(coef, 1, 4); \
+        register_secret_vector.write(##INDEX##, coef); \
+    }
+    gen_secret_vector(0)
+    gen_secret_vector(1)
+    gen_secret_vector(2)
+    gen_secret_vector(3)
+    gen_secret_vector(4)
+    gen_secret_vector(5)
+    gen_secret_vector(6)
+    gen_secret_vector(7)
+    gen_secret_vector(8)
+    gen_secret_vector(9)
+
+
+    #define gen_noise_vector(INDEX) action gen_noise_vector_i##INDEX##() { \
+        bit<32> coef; \
+        random(coef, 1, 4); \
+        register_noise_vector.write(##INDEX##, coef); \
+    }
+    gen_noise_vector(0)
+    gen_noise_vector(1)
+    gen_noise_vector(2)
+    gen_noise_vector(3)
+    gen_noise_vector(4)
+    gen_noise_vector(5)
+    gen_noise_vector(6)
+    gen_noise_vector(7)
+    gen_noise_vector(8)
+    gen_noise_vector(9)
+
+
+    #define matrix_mult(I_A, I_SU, I_TU) action matrix_mult_ia##I_A##_isr##I_SU##_itu##I_TU##() { \
+        bit<32> a;  \
+        bit<32> s_r;  \
+        bit<32> t_u;  \
+        bit<32> temp;  \
+        register_pub_matrix.read(a, ##I_A##);  \
+        register_secret_vector.read(s_r, ##I_SU##);  \
+        register_public_vector_full.read(t_u, ##I_TU##);  \
+        temp = (a * s_r) + t_u;  \
+        register_public_vector_full.write(##I_TU##, temp);  \
+    }
+    matrix_mult(0, 0, 0)
+    matrix_mult(0, 1, 1)
+    matrix_mult(0, 2, 2)
+    matrix_mult(0, 3, 3)
+    matrix_mult(0, 4, 4)
+    matrix_mult(1, 0, 1)
+    matrix_mult(1, 1, 2)
+    matrix_mult(1, 2, 3)
+    matrix_mult(1, 3, 4)
+    matrix_mult(1, 4, 5)
+    matrix_mult(2, 0, 2)
+    matrix_mult(2, 1, 3)
+    matrix_mult(2, 2, 4)
+    matrix_mult(2, 3, 5)
+    matrix_mult(2, 4, 6)
+    matrix_mult(3, 0, 3)
+    matrix_mult(3, 1, 4)
+    matrix_mult(3, 2, 5)
+    matrix_mult(3, 3, 6)
+    matrix_mult(3, 4, 7)
+    matrix_mult(4, 0, 4)
+    matrix_mult(4, 1, 5)
+    matrix_mult(4, 2, 6)
+    matrix_mult(4, 3, 7)
+    matrix_mult(4, 4, 8)
+    matrix_mult(5, 5, 9)
+    matrix_mult(5, 6, 10)
+    matrix_mult(5, 7, 11)
+    matrix_mult(5, 8, 12)
+    matrix_mult(5, 9, 13)
+    matrix_mult(6, 5, 10)
+    matrix_mult(6, 6, 11)
+    matrix_mult(6, 7, 12)
+    matrix_mult(6, 8, 13)
+    matrix_mult(6, 9, 14)
+    matrix_mult(7, 5, 11)
+    matrix_mult(7, 6, 12)
+    matrix_mult(7, 7, 13)
+    matrix_mult(7, 8, 14)
+    matrix_mult(7, 9, 15)
+    matrix_mult(8, 5, 12)
+    matrix_mult(8, 6, 13)
+    matrix_mult(8, 7, 14)
+    matrix_mult(8, 8, 15)
+    matrix_mult(8, 9, 16)
+    matrix_mult(9, 5, 13)
+    matrix_mult(9, 6, 14)
+    matrix_mult(9, 7, 15)
+    matrix_mult(9, 8, 16)
+    matrix_mult(9, 9, 17)
+    matrix_mult(10, 0, 18)
+    matrix_mult(10, 1, 19)
+    matrix_mult(10, 2, 20)
+    matrix_mult(10, 3, 21)
+    matrix_mult(10, 4, 22)
+    matrix_mult(11, 0, 19)
+    matrix_mult(11, 1, 20)
+    matrix_mult(11, 2, 21)
+    matrix_mult(11, 3, 22)
+    matrix_mult(11, 4, 23)
+    matrix_mult(12, 0, 20)
+    matrix_mult(12, 1, 21)
+    matrix_mult(12, 2, 22)
+    matrix_mult(12, 3, 23)
+    matrix_mult(12, 4, 24)
+    matrix_mult(13, 0, 21)
+    matrix_mult(13, 1, 22)
+    matrix_mult(13, 2, 23)
+    matrix_mult(13, 3, 24)
+    matrix_mult(13, 4, 25)
+    matrix_mult(14, 0, 22)
+    matrix_mult(14, 1, 23)
+    matrix_mult(14, 2, 24)
+    matrix_mult(14, 3, 25)
+    matrix_mult(14, 4, 26)
+    matrix_mult(15, 5, 27)
+    matrix_mult(15, 6, 28)
+    matrix_mult(15, 7, 29)
+    matrix_mult(15, 8, 30)
+    matrix_mult(15, 9, 31)
+    matrix_mult(16, 5, 28)
+    matrix_mult(16, 6, 29)
+    matrix_mult(16, 7, 30)
+    matrix_mult(16, 8, 31)
+    matrix_mult(16, 9, 32)
+    matrix_mult(17, 5, 29)
+    matrix_mult(17, 6, 30)
+    matrix_mult(17, 7, 31)
+    matrix_mult(17, 8, 32)
+    matrix_mult(17, 9, 33)
+    matrix_mult(18, 5, 30)
+    matrix_mult(18, 6, 31)
+    matrix_mult(18, 7, 32)
+    matrix_mult(18, 8, 33)
+    matrix_mult(18, 9, 34)
+    matrix_mult(19, 5, 31)
+    matrix_mult(19, 6, 32)
+    matrix_mult(19, 7, 33)
+    matrix_mult(19, 8, 34)
+    matrix_mult(19, 9, 35)
+
+
+    #define poly_pub_add(X, Y, Z) action poly_pub_add_##X##_##Y##_##Z##() { \
+        bit<32> x; \
+        bit<32> y; \
+        bit<32> sum; \
+        register_public_vector_full.read(x, ##X##);  \
+        register_public_vector_full.read(y, ##Y##); \
+        sum = x + y; \
+        register_mod_public_vector.write(##Z##, sum); \
+    }
+    poly_pub_add(0, 9, 0)
+    poly_pub_add(1, 10, 1)
+    poly_pub_add(2, 11, 2)
+    poly_pub_add(3, 12, 3)
+    poly_pub_add(4, 13, 4)
+    poly_pub_add(5, 14, 5)
+    poly_pub_add(6, 15, 6)
+    poly_pub_add(7, 16, 7)
+    poly_pub_add(8, 17, 8)
+    poly_pub_add(18, 27, 9)
+    poly_pub_add(19, 28, 10)
+    poly_pub_add(20, 29, 11)
+    poly_pub_add(21, 30, 12)
+    poly_pub_add(22, 31, 13)
+    poly_pub_add(23, 32, 14)
+    poly_pub_add(24, 33, 15)
+    poly_pub_add(25, 34, 16)
+    poly_pub_add(26, 35, 17)
+
+    #define poly_mod(X, Y, Z) action poly_mod_##X##_##Y##_##Z##() { \
+        bit<32> x; \
+        bit<32> y; \
+        bit<32> e;  \
+        bit<32> minus; \
+        register_mod_public_vector.read(x, ##X##);  \
+        if (##Y## == 100){ \
+            y = 0; \
+        } \
+        else{ \
+            register_mod_public_vector.read(y, ##Y##); \
+        } \
+        hash(x, HashAlgorithm.identity, (bit<32>) 0, {x}, (bit<32>) PARAM_Q); \
+        hash(y, HashAlgorithm.identity, (bit<32>) 0, {y}, (bit<32>) PARAM_Q); \
+        if (x < y){ \
+            x = x + PARAM_Q; \
+        } \
+        minus = x - y; \
+        register_noise_vector.read(e, ##Z##); \
+        minus = minus + e; \
+        hash(minus, HashAlgorithm.identity, (bit<32>) 0, {minus}, (bit<32>) PARAM_Q); \
+        register_public_vector.write(##Z##, minus); \
+        hdr.p4calc.t_##Z## = minus; \
+    }
+    poly_mod(4, 100, 0)
+    poly_mod(5, 0, 1)
+    poly_mod(6, 1, 2)
+    poly_mod(7, 2, 3)
+    poly_mod(8, 3, 4)
+    poly_mod(13, 100, 5)
+    poly_mod(14, 9, 6)
+    poly_mod(15, 10, 7)
+    poly_mod(16, 11, 8)
+    poly_mod(17, 12, 9)
+
+
+    action gen_keys() {
+        register_seed.write(0, hdr.p4calc.seed);
+        gen_matrix_i0_r1();
+        gen_matrix_i1_r1();
+        gen_matrix_i2_r1();
+        gen_matrix_i3_r1();
+        gen_matrix_i4_r1();
+        gen_matrix_i5_r1();
+        gen_matrix_i6_r1();
+        gen_matrix_i7_r1();
+        gen_matrix_i8_r1();
+        gen_matrix_i9_r1();
+        gen_matrix_i10_r1();
+        gen_matrix_i11_r1();
+        gen_matrix_i12_r1();
+        gen_matrix_i13_r1();
+        gen_matrix_i14_r1();
+        gen_matrix_i15_r1();
+        gen_matrix_i16_r1();
+        gen_matrix_i17_r1();
+        gen_matrix_i18_r1();
+        gen_matrix_i19_r1();
+
+        gen_secret_vector_i0();
+        gen_secret_vector_i1();
+        gen_secret_vector_i2();
+        gen_secret_vector_i3();
+        gen_secret_vector_i4();
+        gen_secret_vector_i5();
+        gen_secret_vector_i6();
+        gen_secret_vector_i7();
+        gen_secret_vector_i8();
+        gen_secret_vector_i9();
+
+        gen_noise_vector_i0();
+        gen_noise_vector_i1();
+        gen_noise_vector_i2();
+        gen_noise_vector_i3();
+        gen_noise_vector_i4();
+        gen_noise_vector_i5();
+        gen_noise_vector_i6();
+        gen_noise_vector_i7();
+        gen_noise_vector_i8();
+        gen_noise_vector_i9();
+
+        matrix_mult_ia0_isr0_itu0();
+        matrix_mult_ia0_isr1_itu1();
+        matrix_mult_ia0_isr2_itu2();
+        matrix_mult_ia0_isr3_itu3();
+        matrix_mult_ia0_isr4_itu4();
+        matrix_mult_ia1_isr0_itu1();
+        matrix_mult_ia1_isr1_itu2();
+        matrix_mult_ia1_isr2_itu3();
+        matrix_mult_ia1_isr3_itu4();
+        matrix_mult_ia1_isr4_itu5();
+        matrix_mult_ia2_isr0_itu2();
+        matrix_mult_ia2_isr1_itu3();
+        matrix_mult_ia2_isr2_itu4();
+        matrix_mult_ia2_isr3_itu5();
+        matrix_mult_ia2_isr4_itu6();
+        matrix_mult_ia3_isr0_itu3();
+        matrix_mult_ia3_isr1_itu4();
+        matrix_mult_ia3_isr2_itu5();
+        matrix_mult_ia3_isr3_itu6();
+        matrix_mult_ia3_isr4_itu7();
+        matrix_mult_ia4_isr0_itu4();
+        matrix_mult_ia4_isr1_itu5();
+        matrix_mult_ia4_isr2_itu6();
+        matrix_mult_ia4_isr3_itu7();
+        matrix_mult_ia4_isr4_itu8();
+
+        matrix_mult_ia5_isr5_itu9();
+        matrix_mult_ia5_isr6_itu10();
+        matrix_mult_ia5_isr7_itu11();
+        matrix_mult_ia5_isr8_itu12();
+        matrix_mult_ia5_isr9_itu13();
+        matrix_mult_ia6_isr5_itu10();
+        matrix_mult_ia6_isr6_itu11();
+        matrix_mult_ia6_isr7_itu12();
+        matrix_mult_ia6_isr8_itu13();
+        matrix_mult_ia6_isr9_itu14();
+        matrix_mult_ia7_isr5_itu11();
+        matrix_mult_ia7_isr6_itu12();
+        matrix_mult_ia7_isr7_itu13();
+        matrix_mult_ia7_isr8_itu14();
+        matrix_mult_ia7_isr9_itu15();
+        matrix_mult_ia8_isr5_itu12();
+        matrix_mult_ia8_isr6_itu13();
+        matrix_mult_ia8_isr7_itu14();
+        matrix_mult_ia8_isr8_itu15();
+        matrix_mult_ia8_isr9_itu16();
+        matrix_mult_ia9_isr5_itu13();
+        matrix_mult_ia9_isr6_itu14();
+        matrix_mult_ia9_isr7_itu15();
+        matrix_mult_ia9_isr8_itu16();
+        matrix_mult_ia9_isr9_itu17();
+
+        matrix_mult_ia10_isr0_itu18();
+        matrix_mult_ia10_isr1_itu19();
+        matrix_mult_ia10_isr2_itu20();
+        matrix_mult_ia10_isr3_itu21();
+        matrix_mult_ia10_isr4_itu22();
+        matrix_mult_ia11_isr0_itu19();
+        matrix_mult_ia11_isr1_itu20();
+        matrix_mult_ia11_isr2_itu21();
+        matrix_mult_ia11_isr3_itu22();
+        matrix_mult_ia11_isr4_itu23();
+        matrix_mult_ia12_isr0_itu20();
+        matrix_mult_ia12_isr1_itu21();
+        matrix_mult_ia12_isr2_itu22();
+        matrix_mult_ia12_isr3_itu23();
+        matrix_mult_ia12_isr4_itu24();
+        matrix_mult_ia13_isr0_itu21();
+        matrix_mult_ia13_isr1_itu22();
+        matrix_mult_ia13_isr2_itu23();
+        matrix_mult_ia13_isr3_itu24();
+        matrix_mult_ia13_isr4_itu25();
+        matrix_mult_ia14_isr0_itu22();
+        matrix_mult_ia14_isr1_itu23();
+        matrix_mult_ia14_isr2_itu24();
+        matrix_mult_ia14_isr3_itu25();
+        matrix_mult_ia14_isr4_itu26();
+
+        matrix_mult_ia15_isr5_itu27();
+        matrix_mult_ia15_isr6_itu28();
+        matrix_mult_ia15_isr7_itu29();
+        matrix_mult_ia15_isr8_itu30();
+        matrix_mult_ia15_isr9_itu31();
+        matrix_mult_ia16_isr5_itu28();
+        matrix_mult_ia16_isr6_itu29();
+        matrix_mult_ia16_isr7_itu30();
+        matrix_mult_ia16_isr8_itu31();
+        matrix_mult_ia16_isr9_itu32();
+        matrix_mult_ia17_isr5_itu29();
+        matrix_mult_ia17_isr6_itu30();
+        matrix_mult_ia17_isr7_itu31();
+        matrix_mult_ia17_isr8_itu32();
+        matrix_mult_ia17_isr9_itu33();
+        matrix_mult_ia18_isr5_itu30();
+        matrix_mult_ia18_isr6_itu31();
+        matrix_mult_ia18_isr7_itu32();
+        matrix_mult_ia18_isr8_itu33();
+        matrix_mult_ia18_isr9_itu34();
+        matrix_mult_ia19_isr5_itu31();
+        matrix_mult_ia19_isr6_itu32();
+        matrix_mult_ia19_isr7_itu33();
+        matrix_mult_ia19_isr8_itu34();
+        matrix_mult_ia19_isr9_itu35();
+
+        poly_pub_add_0_9_0();
+        poly_pub_add_1_10_1();
+        poly_pub_add_2_11_2();
+        poly_pub_add_3_12_3();
+        poly_pub_add_4_13_4();
+        poly_pub_add_5_14_5();
+        poly_pub_add_6_15_6();
+        poly_pub_add_7_16_7();
+        poly_pub_add_8_17_8();
+
+        poly_pub_add_18_27_9();
+        poly_pub_add_19_28_10();
+        poly_pub_add_20_29_11();
+        poly_pub_add_21_30_12();
+        poly_pub_add_22_31_13();
+        poly_pub_add_23_32_14();
+        poly_pub_add_24_33_15();
+        poly_pub_add_25_34_16();
+        poly_pub_add_26_35_17();
+
+        poly_mod_4_100_0();
+        poly_mod_5_0_1();
+        poly_mod_6_1_2();
+        poly_mod_7_2_3();
+        poly_mod_8_3_4();
+        poly_mod_13_100_5();
+        poly_mod_14_9_6();
+        poly_mod_15_10_7();
+        poly_mod_16_11_8();
+        poly_mod_17_12_9();
+
+        send_back();
+    }
+
+    action enc() {
+
+        bit<32> e2;
+        random(e2, 0, 4);
+        bit<32> m;
+        random(m, 0, 2);
+
+        send_back();
+    }
+
+    action dec() {
+
+        send_back();
+    }
+
+    action operation_drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    table calculate {
+        key = {
+            hdr.p4calc.op  : exact;
+        }
+        actions = {
+            gen_keys;
+            enc;
+            dec;
+            operation_drop;
+        }
+        const default_action = operation_drop();
+        const entries = {
+            GEN : gen_keys();
+            ENC: enc();
+            DEC  : dec();
+        }
+    }
+
+
+    apply {
+        if (hdr.p4calc.isValid()) {
+            calculate.apply();
+        } else {
+            operation_drop();
+        }
+    }
+}
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply { }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+    apply { }
+}
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.p4calc);
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000056__raw-repositories__f-555__Lemon.p4

@@ -0,0 +1,278 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define HASH_THRESHOLD 1288490189
+
+#define BLOOM_SIZE 65536
+#define PKT_INSTANCE_TYPE_NORMAL 0
+#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1
+#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2
+#define PKT_INSTANCE_TYPE_COALESCED 3
+#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4
+#define PKT_INSTANCE_TYPE_REPLICATION 5
+#define PKT_INSTANCE_TYPE_RESUBMIT 6
+
+const bit<16> TYPE_IPV4 = 0x0800;
+const bit<16> VirtualLAN= 0x8100;
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+typedef bit<16> ether_type_t;
+const ether_type_t ETHERTYPE_IPV4 = 16w0x0800;
+const ether_type_t ETHERTYPE_ARP = 16w0x0806;
+const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd;
+const ether_type_t ETHERTYPE_VLAN = 16w0x8100;
+
+typedef bit<8> ip_protocol_t;
+const ip_protocol_t IP_PROTOCOLS_ICMP = 1;
+const ip_protocol_t IP_PROTOCOLS_TCP = 6;
+const ip_protocol_t IP_PROTOCOLS_UDP = 17;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    tos;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header tcp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<32> seq_no;
+    bit<32> ack_no;
+    bit<4> data_offset;
+    bit<4> res;
+    bit<8> flags;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgent_ptr;
+}
+
+header udp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<16> hdr_length;
+    bit<16> checksum;
+}
+
+header icmp_t {
+    bit<8> type;
+    bit<8> code;
+    bit<16> checksum;
+}
+
+header vlan_tag_h {
+    bit<3> pcp;
+    bit<1> cfi;
+    bit<12> vid;
+    bit<16> type;
+}
+
+struct metadata {   
+    bit<32>  dstip;
+    bit<32>  srcip;
+    bit<16>  srcport;
+    bit<16>  dstport;
+    bit<8>     protocol;
+    bit<8>     kmvflag;
+    bit<32>  khash;
+    bit<32>  counter;
+    bit<16>  epoch;
+}
+
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t        ipv4;
+    udp_t        udp;
+    tcp_t          tcp;
+    icmp_t      icmp;
+    vlan_tag_h vlan;
+}
+
+ 
+
+
+ 
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+ 
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType){
+            TYPE_IPV4: ipv4;
+            VirtualLAN:vlan;
+            default: accept;
+        }
+    }
+ 
+    state vlan{
+        packet.extract(hdr.vlan);
+        transition select(hdr.vlan.type){
+            TYPE_IPV4: ipv4;
+            default: accept;
+        }
+    }
+
+    state ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol){
+            IP_PROTOCOLS_TCP : parse_tcp;
+            IP_PROTOCOLS_UDP : parse_udp;
+            IP_PROTOCOLS_ICMP : parse_icmp;
+            default : accept;
+        }
+    }
+
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        transition accept;
+    }
+
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;
+    }
+    state parse_icmp {
+        packet.extract(hdr.icmp);
+        transition accept;
+    }
+}
+
+ 
+
+ 
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+ 
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+
+    action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) {
+        hash(rhash, HashAlgorithm.crc16, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w12);
+    }
+    
+    action forward(in bit<32> rhash){
+       bit<9> finalport = 1;
+       finalport=rhash[8:0] +1;
+       if( finalport >= 12) 
+           finalport = 12;
+       if( finalport < 1) 
+           finalport = 1;
+       if(standard_metadata.ingress_port != 14) {
+           finalport = 0;
+       }
+       standard_metadata.egress_spec = finalport;
+    }
+
+    apply {
+        bit<32> rhash=1;
+        if (hdr.tcp.isValid()) {
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash);
+            forward(rhash);
+        }
+        else if (hdr.udp.isValid()) {
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash);
+            forward(rhash);
+        }else{
+            standard_metadata.egress_spec = 0;
+        }
+
+       if(standard_metadata.ingress_port != 14) {
+           standard_metadata.egress_spec = 0;
+       }
+    }
+}
+
+ 
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {
+    }
+}
+ 
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.tos,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+ 
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+//parsed headers have to be added again into the packet.
+        packet.emit(hdr.ethernet);    
+        packet.emit(hdr.vlan);     
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.tcp);
+        packet.emit(hdr.udp);
+        packet.emit(hdr.icmp);
+    }
+}
+
+
+
+
+
+//switch architecture
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000057__raw-repositories__f-555__Lemon.p4

@@ -0,0 +1,471 @@
+/*Lemon sketch for packets counting per-dstIP */
+#include <core.p4>
+#include <v1model.p4>
+
+#define PKT_INSTANCE_TYPE_NORMAL 0
+#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1
+#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2
+#define PKT_INSTANCE_TYPE_COALESCED 3
+#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4
+#define PKT_INSTANCE_TYPE_REPLICATION 5
+#define PKT_INSTANCE_TYPE_RESUBMIT 6
+#define HEAVY_T 100
+
+#define T1 16384
+#define T2 8192
+#define T3 1024
+#define T4 256
+#define Th 256
+
+#define layer1_size 32w524288
+#define layer2_size 32w65536
+#define layer3_size 32w8192
+#define layer4_size 32w2048
+#define layer5_size 32w1024
+
+#define layer1_size_bit1 32w4194304
+#define layer2_size_bit1 32w2097152
+#define layer3_size_bit1 32w262144
+#define layer4_size_bit1 32w65536
+#define layer5_size_bit1 32w524288
+
+#define l1_bitmap 32w8
+#define l2_bitmap 32w32
+#define l3_bitmap 32w32
+#define l4_bitmap 32w32
+#define l5_bitmap 32w512
+
+#define Hsize 32w8192
+
+const bit<16> TYPE_IPV4 = 0x0800;
+const bit<16> VirtualLAN= 0x8100;
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+typedef bit<16> ether_type_t;
+const ether_type_t ETHERTYPE_IPV4 = 16w0x0800;
+const ether_type_t ETHERTYPE_ARP = 16w0x0806;
+const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd;
+const ether_type_t ETHERTYPE_VLAN = 16w0x8100;
+
+typedef bit<8> ip_protocol_t;
+const ip_protocol_t IP_PROTOCOLS_ICMP = 1;
+const ip_protocol_t IP_PROTOCOLS_TCP = 6;
+const ip_protocol_t IP_PROTOCOLS_UDP = 17;
+
+
+header cpu_t {
+    bit<32> hash;
+    bit<32> hash1;
+    bit<32> srcip;
+    bit<32> dstip;
+    bit<16> srcport;
+    bit<16> dstport;
+    bit<8> protocol;
+    bit<32> counter;
+    bit<16> epoch;
+    bit <8> outputport;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    tos;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header tcp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<32> seq_no;
+    bit<32> ack_no;
+    bit<4> data_offset;
+    bit<4> res;
+    bit<8> flags;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgent_ptr;
+    bit<16> payload;
+}
+
+header udp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<16> hdr_length;
+    bit<16> checksum;
+    bit<16> payload;
+}
+
+header icmp_t {
+    bit<8> type;
+    bit<8> code;
+    bit<16> checksum;
+}
+
+header vlan_tag_h {
+    bit<3> pcp;
+    bit<1> cfi;
+    bit<12> vid;
+    bit<16> type;
+}
+
+struct metadata {   
+    bit<32>  dstip;
+    bit<32>  srcip;
+    bit<16>  srcport;
+    bit<16>  dstport;
+    bit<8>   protocol;
+    bit<8>   kmvflag;
+    bit<32>  khash;
+    bit<32>  khash1;
+    bit<32>  counter;
+    bit<16>  epoch;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t        ipv4;
+    cpu_t         cpu;
+    udp_t        udp;
+    tcp_t          tcp;
+    icmp_t      icmp;
+    vlan_tag_h vlan;
+}
+
+
+ 
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+ 
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType){
+            TYPE_IPV4: ipv4;
+            VirtualLAN:vlan;
+            default: accept;
+        }
+    }
+ 
+    state vlan{
+        packet.extract(hdr.vlan);
+        transition select(hdr.vlan.type){
+            TYPE_IPV4: ipv4;
+            default: accept;
+        }
+    }
+
+    state ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol){
+            IP_PROTOCOLS_TCP : parse_tcp;
+            IP_PROTOCOLS_UDP : parse_udp;
+
+            default : reject;
+        }
+    }
+
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        transition accept;
+    }
+
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;
+    }
+    state parse_icmp {
+        packet.extract(hdr.icmp);
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+ 
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    register<bit<1>>(layer1_size_bit1) lemon_layer1;
+    register<bit<1>>(layer2_size_bit1) lemon_layer2;
+    register<bit<1>>(layer3_size_bit1) lemon_layer3;
+    register<bit<1>>(layer4_size_bit1) lemon_layer4;
+    register<bit<1>>(layer5_size_bit1) lemon_layer5;
+
+    register<bit<16>>(4) hash_deep_threshold;
+
+    register<bit<32>>(layer1_size) counter;
+
+    register<bit<32>>(8192) lemon_heavy_id;
+
+    register<bit<32>>(8192) lemon_heavy_tag;
+
+
+    register<bit<32>>(1) sip_mask_f;
+    register<bit<32>>(1) dip_mask_f;
+    register<bit<16>>(1) sport_mask_f;
+    register<bit<16>>(1) dport_mask_f;
+    register<bit<8>>(1) protol_f;
+
+    register<bit<32>>(1) sip_mask;
+    register<bit<32>>(1) dip_mask;
+    register<bit<16>>(1) sport_mask;
+    register<bit<16>>(1) dport_mask;
+    register<bit<8>>(1) protol;
+    register<bit<16>>(1) ip_checksum;
+    register<bit<16>>(1) transport_checksum;
+    register<bit<16>>(1) perpkt_tag;
+ 
+    action deep_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> ipsum, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<16> payload,out bit<16> dhash){
+        hash(dhash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,ipsum,checksum,seq_no,hdlen,payload}, 16w65535);
+    }
+
+    action slot_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> shash) {
+        hash(shash, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, layer1_size);
+    }
+
+    action bitmap_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> ipsum, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<16> payload,out bit<32> bhash) {
+        hash(bhash, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,ipsum,checksum,seq_no,hdlen,payload}, l5_bitmap);
+    }
+
+    action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) {
+        hash(rhash, HashAlgorithm.crc32_custom, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w3);
+    }
+    
+    action slot_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> shash) {
+        hash(shash, HashAlgorithm.identity, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, layer1_size);
+    }
+
+    register<bit<32>>(Hsize) Heavy_dst;
+
+    action forward(in bit<32> rhash){
+        bit<9> finalport = 1;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+
+        if(hdr.ipv4.ttl == 0)
+            finalport = 10;
+
+        standard_metadata.egress_spec = 1;
+
+// for chuanxing
+    }
+
+    apply {
+
+        bit<32> rhash;
+
+//only if IPV4 the rule is applied. Therefore other packets will not be forwarded.
+        if (hdr.ipv4.isValid()){
+
+            meta.srcip=hdr.ipv4.srcAddr;
+            meta.dstip=hdr.ipv4.dstAddr;
+            meta.protocol=hdr.ipv4.protocol;
+        }
+
+        bit<16> deep_h = 0;
+	    bit<32> slot_h = 0;
+        bit<32> slot_h2 = 0;
+        bit<32> bitmap_h = 0;
+
+
+        bit<32> sip_mask_f = 0;
+
+        bit<32> dip_mask_f = 0xffffffff;
+        bit<16> sport_mask_f = 0;
+        bit<16> dport_mask_f = 0;
+        bit<8> protocol_mask_f = 0;
+
+        bit<32> sip_mask = 0xffffffff;
+        bit<32> dip_mask = 0xffffffff;
+        bit<16> sport_mask = 0xffff;
+        bit<16> dport_mask = 0xffff;
+        bit<8> protocol_mask = 0xff;
+        bit<16> ip_checksum_mask = 0xffff;
+        bit<16> transport_checksum_mask = 0xffff;
+        bit<16> payload_mask = 0xffff;
+
+        if (hdr.tcp.isValid()) {
+            deep_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.tcp.checksum,hdr.tcp.seq_no, 0, hdr.tcp.payload, deep_h);
+            slot_hash(hdr.ipv4.srcAddr & sip_mask_f, hdr.ipv4.dstAddr & dip_mask_f, hdr.tcp.src_port & sport_mask_f, hdr.tcp.dst_port & dport_mask_f,hdr.ipv4.protocol & protocol_mask_f, slot_h);
+            bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.tcp.checksum,hdr.tcp.seq_no, 0, 0, bitmap_h);
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash);
+
+//forward(rhash);
+        }
+        else if (hdr.udp.isValid()) {
+            deep_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, deep_h);
+            slot_hash(hdr.ipv4.srcAddr & sip_mask_f, hdr.ipv4.dstAddr & dip_mask_f, hdr.udp.src_port & sport_mask_f, hdr.udp.dst_port & dport_mask_f,hdr.ipv4.protocol & protocol_mask_f, slot_h);
+	        bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, bitmap_h);
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash);
+
+//forward(rhash);
+        }
+
+
+
+        bit<16> deep1;
+        bit<16> deep2;
+        bit<16> deep3;
+        bit<16> deep4;
+
+        hash_deep_threshold.write(0, T1);
+        hash_deep_threshold.write(1, T2);
+        hash_deep_threshold.write(2, T3);
+        hash_deep_threshold.write(3, T4);
+
+        hash_deep_threshold.read(deep1,0);
+        hash_deep_threshold.read(deep2,1);
+        hash_deep_threshold.read(deep3,2);
+        hash_deep_threshold.read(deep4,3);
+
+                   
+        bit<32> counter_hash = 0;
+        bit<32> counter_val = 0;
+        counter_hash[18:0] = slot_h[18:0];
+        counter.read(counter_val, counter_hash);
+        counter_val = counter_val + 1;
+        counter.write(counter_hash,counter_val);
+
+        bit<16> roll = 0;
+        if(deep_h<=deep4){
+            bit<32> slot = 0;
+            slot[18:9] = slot_h[9:0];
+            slot[8:0] = bitmap_h[8:0];
+
+            lemon_layer5.write(slot,1);
+        }
+        if(deep_h<=deep3 && deep_h>deep4){
+            bit<32> slot = 0;
+            slot[15:5] = slot_h[10:0];
+            slot[4:0] = bitmap_h[4:0];
+
+            lemon_layer4.write(slot,1);
+        }
+        if(deep_h<=deep2 && deep_h>deep3){
+
+            bit<32> slot = 0;
+            slot[17:5] = slot_h[12:0];
+            slot[4:0] = bitmap_h[4:0];
+
+            lemon_layer3.write(slot,1);
+        }
+        if(deep_h<=deep1 && deep_h>deep2){
+
+            bit<32> slot = 0;
+            slot[20:5] = slot_h[15:0];
+            slot[4:0] = bitmap_h[4:0];
+
+            lemon_layer2.write(slot,1);
+        }
+        if(deep_h > deep1){
+
+            bit<32> slot = 0;
+            slot[21:3] = slot_h[18:0];
+            slot[2:0] = bitmap_h[2:0];
+
+            lemon_layer1.write(slot,1);
+        }
+        if(deep_h < deep3){
+            bit<32> slot = 0;
+            slot[12:0] = slot_h[12:0];
+            lemon_heavy_id.write(slot,hdr.ipv4.dstAddr);
+            lemon_heavy_tag.write(slot,slot_h);
+        }
+        hdr.ipv4.srcAddr[31:0] = 0;
+
+        hdr.ipv4.identification[15:0] = deep_h;
+        standard_metadata.egress_spec = 1;
+    }
+}
+
+ 
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {
+
+    }
+
+}
+ 
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.tos,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+ 
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+//parsed headers have to be added again into the packet.
+
+    }
+}
+
+
+
+
+
+//switch architecture
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000058__raw-repositories__f-555__Lemon.p4

@@ -0,0 +1,454 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define PKT_INSTANCE_TYPE_NORMAL 0
+#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1
+#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2
+#define PKT_INSTANCE_TYPE_COALESCED 3
+#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4
+#define PKT_INSTANCE_TYPE_REPLICATION 5
+#define PKT_INSTANCE_TYPE_RESUBMIT 6
+#define HEAVY_T 25
+
+#define Lsize 32w524288
+
+// 8*8192 256 bitmap
+#define Lsize_bitmap 32w16
+
+#define Lsize_totle 32w8388608
+
+#define Hsize 32w1024
+
+// size of heavy part
+#define Hsize_hll 32w32
+
+//
+#define Hsize_totle 32w524288
+
+
+const bit<16> TYPE_IPV4 = 0x0800;
+const bit<16> VirtualLAN= 0x8100;
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+typedef bit<16> ether_type_t;
+const ether_type_t ETHERTYPE_IPV4 = 16w0x0800;
+const ether_type_t ETHERTYPE_ARP = 16w0x0806;
+const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd;
+const ether_type_t ETHERTYPE_VLAN = 16w0x8100;
+
+typedef bit<8> ip_protocol_t;
+const ip_protocol_t IP_PROTOCOLS_ICMP = 1;
+const ip_protocol_t IP_PROTOCOLS_TCP = 6;
+const ip_protocol_t IP_PROTOCOLS_UDP = 17;
+
+
+header cpu_t {
+    bit<32> hash;
+    bit<32> hash1;
+    bit<32> srcip;
+    bit<32> dstip;
+    bit<16> srcport;
+    bit<16> dstport;
+    bit<8> protocol;
+    bit<32> counter;
+    bit<16> epoch;
+    bit <8> outputport;
+}
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    tos;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header tcp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<32> seq_no;
+    bit<32> ack_no;
+    bit<4> data_offset;
+    bit<4> res;
+    bit<8> flags;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgent_ptr;
+}
+
+header udp_t {
+    bit<16> src_port;
+    bit<16> dst_port;
+    bit<16> hdr_length;
+    bit<16> checksum;
+    bit<48> payload;
+}
+
+header icmp_t {
+    bit<8> type;
+    bit<8> code;
+    bit<16> checksum;
+}
+
+header vlan_tag_h {
+    bit<3> pcp;
+    bit<1> cfi;
+    bit<12> vid;
+    bit<16> type;
+}
+
+struct metadata {   
+    bit<32>  dstip;
+    bit<32>  srcip;
+    bit<16>  srcport;
+    bit<16>  dstport;
+    bit<8>   protocol;
+    bit<8>   hllflag;
+    bit<32>  khash;
+    bit<32>  khash1;
+    bit<32>  counter;
+    bit<16>  epoch;
+}
+
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t        ipv4;
+    cpu_t         cpu;
+    udp_t        udp;
+    tcp_t          tcp;
+    icmp_t      icmp;
+    vlan_tag_h vlan;
+}
+
+
+ 
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+ 
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType){
+            TYPE_IPV4: ipv4;
+            VirtualLAN:vlan;
+            default: accept;
+        }
+    }
+ 
+    state vlan{
+        packet.extract(hdr.vlan);
+        transition select(hdr.vlan.type){
+            TYPE_IPV4: ipv4;
+            default: accept;
+        }
+    }
+
+    state ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol){
+            IP_PROTOCOLS_TCP : parse_tcp;
+            IP_PROTOCOLS_UDP : parse_udp;
+            IP_PROTOCOLS_ICMP : parse_icmp;
+            default : accept;
+        }
+    }
+
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        transition accept;
+    }
+
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;
+    }
+    state parse_icmp {
+        packet.extract(hdr.icmp);
+        transition accept;
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+ 
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    register<bit<16>>(Lsize) Light_counter1;
+    register<bit<1>>(Lsize_totle) Light_1;
+
+
+    register<bit<16>>(Hsize_totle) Heavy;
+    register<bit<32>>(Hsize) Heavy_sip;
+    register<bit<32>>(Hsize) Heavy_dip;
+    register<bit<16>>(Hsize) Heavy_sp;
+    register<bit<16>>(Hsize) Heavy_dp;
+    register<bit<8>>(Hsize) Heavy_prot;
+    register<bit<32>>(Hsize) Heavy_lhash1;
+    register<bit<32>>(Hsize) Heavy_lhash2;
+
+    register<bit<32>>(1) pkgcounter;
+    register<bit<16>>(1) epoch;
+
+    action bloom_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<32> h1, out bit<32> h2, out bit<32> h3) {
+        hash(h1, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff);
+        hash(h2, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff);
+        hash(h3, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff);
+    }
+ 
+    action light_slot_hash1(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) {
+        hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Lsize);
+    }
+    action light_slot_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) {
+        hash(khash, HashAlgorithm.identity, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Lsize);
+    }
+    action bitmap_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload,out bit<32> khash) {
+        hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, Lsize_bitmap);
+    }
+
+    action heavy_slot_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) {
+        hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Hsize);
+    }
+    action heavy_slot_armoma_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<32> khash) {
+        hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, Hsize_hll);
+    }
+    action hll_hash1(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<16> khash) {
+        hash(khash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, 16w0xffff);
+    }
+    action hll_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<16> khash) {
+        hash(khash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, 16w0xffff);
+    }
+
+
+    action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) {
+        hash(rhash, HashAlgorithm.crc32, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w3);
+    }
+
+    action forward(in bit<32> rhash){
+        bit<9> finalport = 1;
+        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
+
+        if(hdr.ipv4.ttl == 0)
+            finalport = 10;
+        standard_metadata.egress_spec = finalport+1; 
+    }
+
+    apply {
+
+        bit<32> rhash;
+
+//only if IPV4 the rule is applied. Therefore other packets will not be forwarded.
+        if (hdr.ipv4.isValid()){
+            meta.srcip=hdr.ipv4.srcAddr;
+            meta.dstip=hdr.ipv4.dstAddr;
+            meta.protocol=hdr.ipv4.protocol;
+        }
+
+
+        bit<32> h1=0;
+        bit<32> h2=0;
+        bit<32> h3=0;
+
+	    bit<32> light_slot_h1=0;
+        bit<32> bitmap_h=0;
+
+        bit<32> heavy_slot_h=0;
+        bit<32> heavy_slot_armoma_h=0;
+        bit<16> khash1=0;
+        bit<16> khash2=0;
+
+        if (hdr.tcp.isValid()) {
+            bloom_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, h1, h2, h3);
+            
+            light_slot_hash1(0, hdr.ipv4.dstAddr, 0, 0, 0, light_slot_h1);
+
+	        bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no , 0,0 , bitmap_h);
+            
+            heavy_slot_hash(0, hdr.ipv4.dstAddr, 0, 0, 0, heavy_slot_h);
+            heavy_slot_armoma_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, heavy_slot_armoma_h);
+            hll_hash1(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, khash1);
+            hll_hash2(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, khash2);
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash);
+
+	        khash1[7:4]=khash2[7:4];
+            forward(rhash);
+        }
+        else if (hdr.udp.isValid()) {
+            bloom_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload,h1, h2, h3);
+            
+            light_slot_hash1(0, hdr.ipv4.dstAddr, 0, 0, 0, light_slot_h1);
+
+	        bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, bitmap_h);
+            
+            heavy_slot_hash(0, hdr.ipv4.dstAddr, 0, 0, 0, heavy_slot_h);
+            heavy_slot_armoma_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, heavy_slot_armoma_h);
+            hll_hash1(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, khash1);
+            hll_hash2(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, khash2);
+            routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash);
+
+	        khash1[7:4]=khash2[7:4];
+            forward(rhash);
+        }else{
+            standard_metadata.egress_spec =0;
+        }
+
+
+        bit<16> counternow1 = 0;
+        bit<16> counternow2 = 0;
+        bit<16> heavy_flag = 0;
+        Light_counter1.read(counternow1,light_slot_h1);
+        counternow1 = counternow1 +1;
+        Light_counter1.write(light_slot_h1,counternow1);
+        
+        if(counternow1 >= HEAVY_T) 
+            heavy_flag = 1;
+
+        if(heavy_flag == 0){
+            bit<32> l_index = 0;
+            bit<32> bitmap1 = 0;
+            bit<8> roll = 0;
+
+// for bitmap
+            l_index[22:4] = light_slot_h1[18:0];
+            l_index[3:0] = bitmap_h[3:0];
+            Light_1.write(l_index,1);
+        }
+
+        bit<16> hashnow;
+        bit<32> h_index;
+        h_index[14:5]=heavy_slot_h[9:0];
+        h_index[4:0]=heavy_slot_armoma_h[4:0];
+        if(heavy_flag == 1){
+            Heavy.read(hashnow,h_index);
+            if((hashnow > khash1 || hashnow==0)){
+                Heavy.write(h_index,khash1);
+            }
+            Heavy_sip.write(heavy_slot_h,hdr.ipv4.srcAddr);
+            Heavy_dip.write(heavy_slot_h,hdr.ipv4.dstAddr);
+            Heavy_prot.write(heavy_slot_h,hdr.ipv4.protocol);
+            Heavy_lhash1.write(heavy_slot_h, light_slot_h1);
+            if(hdr.tcp.isValid()){
+                Heavy_sp.write(heavy_slot_h,hdr.tcp.src_port);        
+                Heavy_dp.write(heavy_slot_h,hdr.tcp.dst_port);                           
+            }
+            if(hdr.udp.isValid()){
+                Heavy_sp.write(heavy_slot_h,hdr.udp.src_port);        
+                Heavy_dp.write(heavy_slot_h,hdr.udp.dst_port);               
+            }
+        }
+    }
+}
+
+ 
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {
+
+     if (standard_metadata.instance_type != 0){
+        hdr.ethernet.etherType =0x1234;       
+        hdr.cpu.setValid();                                       
+        hdr.vlan.setInvalid();                                       
+        hdr.cpu.hash = meta.khash;
+        hdr.cpu.hash1 = meta.khash1;
+        hdr.cpu.srcip = meta.srcip;  
+        hdr.cpu.dstip = meta.dstip;
+        hdr.cpu.srcport = meta.srcport;
+        hdr.cpu.dstport = meta.dstport;
+        hdr.cpu.protocol = meta.protocol;
+        hdr.cpu.counter = meta.counter;
+        hdr.cpu.epoch= meta.epoch;
+        hdr.cpu.outputport = standard_metadata.egress_spec[7:0];
+     }
+    }
+
+}
+ 
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+        update_checksum(
+            hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+              hdr.ipv4.ihl,
+              hdr.ipv4.tos,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+ 
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+//parsed headers have to be added again into the packet.
+        packet.emit(hdr.ethernet);    
+        packet.emit(hdr.vlan);    
+        packet.emit(hdr.cpu);   
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.tcp);
+        packet.emit(hdr.udp);
+        packet.emit(hdr.icmp);
+    }
+}
+
+
+
+
+
+//switch architecture
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000059__raw-repositories__diogocampos__p4-data-flow.p4

@@ -0,0 +1,287 @@
+#include <v1model.p4>
+
+
+typedef bit<48> mac_addr_t;
+typedef bit<128> ipv6_addr_t;
+typedef bit<9> port_t;
+const bit<16> TYPE_IPV6 = 0x86dd;
+const bit<9> TYPE_CPU = 9w192;
+const bit<8> PROTO_TCP = 6;
+const bit<8> PROTO_UDP = 17;
+const bit<8> PROTO_ICMP6 = 58;
+const bit<8> TCP_SEQ_LEN = 4;
+const bit<8> ICMP6_ECHO_REQUEST = 128;
+const bit<8> ICMP6_ECHO_REPLY = 129;
+
+header ethernet_t {
+    mac_addr_t dstAddr;
+    mac_addr_t srcAddr;
+    bit<16>    etherType;
+}
+
+header ipv6_t {
+    bit<4>      version;
+    bit<8>      traffic_class;
+    bit<20>     flow_label;
+    bit<16>     payload_length;
+    bit<8>      nextHdr;
+    bit<8>      hopLimit;
+    ipv6_addr_t srcAddr;
+    ipv6_addr_t dstAddr;
+}
+
+header tcp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    int<32> seqNo;
+    int<32> ackNo;
+    bit<4>  data_offset;
+    bit<4>  res;
+    bit<1>  cwr;
+    bit<1>  ece;
+    bit<1>  urg;
+    bit<1>  ack;
+    bit<1>  psh;
+    bit<1>  rst;
+    bit<1>  syn;
+    bit<1>  fin;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+header udp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<16> length_;
+    bit<16> checksum;
+}
+
+header icmp6_t {
+    bit<8>   type;
+    bit<8>   code;
+    bit<16>  checksum;
+}
+
+struct headers {
+    ethernet_t inner_ethernet;
+    icmp6_t    inner_icmp6;
+    ipv6_t     inner_ipv6;
+    tcp_t      inner_tcp;
+    udp_t      inner_udp;
+    ethernet_t ethernet;
+    icmp6_t    icmp6;    
+    ipv6_t     ipv6;
+    tcp_t      tcp;
+    udp_t      udp;
+}
+
+struct l3_metadata_t {
+    bit<2>  lkp_ip_type;
+    bit<4>  lkp_ip_version;
+    bit<8>  lkp_ip_proto;
+    bit<8>  lkp_dscp;
+    bit<8>  lkp_ip_ttl;
+    bit<16> lkp_l4_sport;
+    bit<16> lkp_l4_dport;
+    bit<16> lkp_outer_l4_sport;
+    bit<16> lkp_outer_l4_dport;
+    bit<16> vrf;
+    bit<10> rmac_group;
+    bit<1>  rmac_hit;
+    bit<2>  urpf_mode;
+    bit<1>  urpf_hit;
+    bit<1>  urpf_check_fail;
+    bit<16> urpf_bd_group;
+    bit<1>  fib_hit;
+    bit<16> fib_nexthop;
+    bit<2>  fib_nexthop_type;
+    bit<16> same_bd_check;
+    bit<16> nexthop_index;
+    bit<1>  routed;
+    bit<1>  outer_routed;
+    bit<8>  mtu_index;
+    bit<1>  l3_copy;
+    bit<16> l3_mtu_check;
+    bit<16> egress_l4_sport;
+    bit<16> egress_l4_dport;
+}
+
+struct tunnel_metadata_t {
+    bit<5>  ingress_tunnel_type;
+    bit<24> tunnel_vni;
+    bit<5>  egress_tunnel_type;
+    bit<14> tunnel_index;
+    bit<9>  tunnel_src_index;
+    bit<9>  tunnel_smac_index;
+    bit<14> tunnel_dst_index;
+    bit<14> tunnel_dmac_index;
+    bit<24> vnid;
+    bit<1>  tunnel_terminate;
+    bit<1>  tunnel_if_check;
+    bit<4>  egress_header_count;
+    bit<8>  inner_ip_proto;
+    bit<1>  skip_encap_inner;
+}
+
+struct l2_metadata_t {
+    bit<48> lkp_mac_sa;
+    bit<48> lkp_mac_da;
+    bit<3>  lkp_pkt_type;
+    bit<16> lkp_mac_type;
+    bit<3>  lkp_pcp;
+    bit<16> l2_nexthop;
+    bit<2>  l2_nexthop_type;
+    bit<1>  l2_redirect;
+    bit<1>  l2_src_miss;
+    bit<16> l2_src_move;
+    bit<10> stp_group;
+    bit<3>  stp_state;
+    bit<16> bd_stats_idx;
+    bit<1>  learning_enabled;
+    bit<1>  port_vlan_mapping_miss;
+    bit<16> same_if_check;
+}
+
+struct ipv6_metadata_t {
+    bit<128> lkp_ipv6_sa;
+    bit<128> lkp_ipv6_da;
+    bit<1>   ipv6_unicast_enabled;
+    bit<1>   ipv6_src_is_link_local;
+    bit<2>   ipv6_urpf_mode;
+}
+
+struct acl_metadata_t {
+    bit<1> acl_deny;                      /* ifacl/vacl deny action */
+    bit<24> vnid;                         /* vnid for acls */
+    bit<14> acl_stats_index;              /* acl stats index */
+    bit<16> egress_if_label;              /* if label for egress acls */
+    bit<16> egress_bd_label;              /* bd label for egress acls */
+}
+
+struct fwd_meta_t {
+    bit<32> l2ptr;
+    bit<24> out_bd;
+}
+
+struct metadata_t {
+    port_t  ingress_port;
+    port_t  egress_port;
+    bit<16> tcp_length;
+    bit<32> cast_length;
+    bit<1>  do_cksum;
+    l2_metadata_t l2_metadata;
+    l3_metadata_t l3_metadata;
+    ipv6_metadata_t ipv6_metadata;
+    tunnel_metadata_t tunnel_metadata;
+    fwd_meta_t     fwd;    
+}
+
+
+const bit<32> BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION   = 5;
+#define IS_REPLICATED(std_meta) (std_meta.instance_type == BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION)
+
+parser MyParser(packet_in packet, out headers hdr, inout metadata_t meta,
+                inout standard_metadata_t standard_metadata) {
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            TYPE_IPV6: ipv6;
+            default: accept;
+        }
+    }
+    state ipv6 {
+        packet.extract(hdr.ipv6);
+        transition select(hdr.ipv6.nextHdr) {
+            PROTO_UDP: parse_udp;
+            PROTO_ICMP6: icmp6;
+            default: accept;
+        }
+    }
+    state icmp6 {
+        packet.extract(hdr.icmp6);
+        transition accept;
+    }
+    state parse_udp {
+        packet.extract(hdr.udp);
+        transition accept;	
+    }
+}
+
+
+control ingress(inout headers hdr, inout metadata_t meta,
+                inout standard_metadata_t standard_metadata) {
+    action set_mcast_grp(bit<16> mcast_grp, bit<9> port) {
+        standard_metadata.mcast_grp = mcast_grp;
+	meta.egress_port = port;
+    }
+    table ipv6_tbl {
+	key = {
+            (hdr.ipv6.dstAddr[127:120] == 8w0xff) : exact @name("mcast_key");
+	}
+	actions = {set_mcast_grp;}
+    }
+
+    apply {
+        if (hdr.ipv6.isValid()) {
+	    ipv6_tbl.apply();
+        }
+    }
+}
+
+control egress(inout headers hdr, inout metadata_t meta,
+               inout standard_metadata_t standard_metadata) {
+    action set_out_bd (bit<24> bd) {
+        meta.fwd.out_bd = bd;
+    }
+    table get_multicast_copy_out_bd {
+        key = {
+            standard_metadata.mcast_grp  : exact;
+            standard_metadata.egress_rid : exact;
+        }
+        actions = { set_out_bd; }
+    }
+
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+    action rewrite_mac(bit<48> smac) {
+        hdr.ethernet.srcAddr = smac;
+    }
+    table send_frame {
+        key = {
+            meta.fwd.out_bd: exact;
+        }
+        actions = {rewrite_mac; drop;}
+        default_action = drop;
+    }
+
+    apply {
+        if (IS_REPLICATED(standard_metadata)) {
+            get_multicast_copy_out_bd.apply();
+	    send_frame.apply();
+	}
+    }
+}
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv6);
+        packet.emit(hdr.icmp6);
+        packet.emit(hdr.udp);
+    }
+}
+
+control MyVerifyChecksum(inout headers hdr, inout metadata_t meta) {
+    apply {
+    }
+}
+
+control MyComputeChecksum(inout headers hdr, inout metadata_t meta) {
+    apply {
+    }
+}
+
+V1Switch(MyParser(), MyVerifyChecksum(), ingress(), egress(),
+MyComputeChecksum(), MyDeparser()) main;

individual_files/000060__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,285 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header arp_t {
+  bit<16> ptype;
+  bit<8> plen;
+  bit<16> oper;
+  bit<16> htype;
+  bit<8> hlen;
+}
+header arp_ipv4_t {
+  bit<32> tpa;
+  bit<48> tha;
+  bit<32> spa;
+  bit<48> sha;
+}
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header icmp_t {
+  bit<8> type;
+  bit<16> checksum;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<32> srcAddr;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  arp_t arp;
+  arp_ipv4_t arp_ipv4;
+  ethernet_t ethernet;
+  icmp_t icmp;
+  ipv4_t ipv4;
+}
+
+  
+
+// METADATA
+
+
+struct my_metadata_t {
+
+  bit<48> my_mac;
+  bit<48> mac_sa;
+  bit<48> mac_da;
+  bit<9> egress_port;
+  bit<32> dst_ipv4;
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_arp {
+    packet.extract(hdr.arp);
+    transition select(hdr.arp.htype,hdr.arp.ptype,hdr.arp.hlen,hdr.arp.plen){
+      (16w1,16w2048,8w6,8w4) : parse_arp_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_arp_ipv4 {
+    packet.extract(hdr.arp_ipv4);
+    meta.dst_ipv4 = hdr.arp_ipv4.tpa;
+    transition accept;
+  }
+    
+
+  state parse_icmp {
+    packet.extract(hdr.icmp);
+    transition accept;
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    meta.dst_ipv4 = hdr.ipv4.dstAddr;
+    transition select(hdr.ipv4.protocol){
+      (8w1) : parse_icmp;
+      default : accept;
+    }
+
+  }
+    
+
+  state start {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      (16w2054) : parse_arp;
+      default : accept;
+    }
+
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<9> egress_port;
+  bit<1> exited;
+  bit<48> mac_da;
+  bit<48> mac_sa;
+  bit<32> tmp_ip;
+  bit<48> tmp_mac;
+
+
+// Action Definitions
+  action forward_action_0(){
+    hdr.ethernet.dstAddr = meta.mac_da;
+    hdr.ethernet.srcAddr = meta.mac_sa;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl - 8w1);
+    standard_metadata.egress_spec = meta.egress_port;
+  }
+
+  action forward_action_1(){
+    hdr.ethernet.dstAddr = hdr.arp_ipv4.sha;
+    hdr.ethernet.srcAddr = meta.mac_da;
+    hdr.arp.oper = 16w2;
+    hdr.arp_ipv4.tha = hdr.arp_ipv4.sha;
+    hdr.arp_ipv4.tpa = hdr.arp_ipv4.spa;
+    hdr.arp_ipv4.sha = meta.mac_da;
+    hdr.arp_ipv4.spa = meta.dst_ipv4;
+    standard_metadata.egress_spec = standard_metadata.ingress_port;
+  }
+
+  action forward_action_2(){
+    tmp_mac = hdr.ethernet.dstAddr;
+    hdr.ethernet.dstAddr = hdr.ethernet.srcAddr;
+    hdr.ethernet.srcAddr = tmp_mac;
+    tmp_ip = hdr.ipv4.dstAddr;
+    hdr.ipv4.dstAddr = hdr.ipv4.srcAddr;
+    hdr.ipv4.srcAddr = tmp_ip;
+    hdr.icmp.type = 8w0;
+    hdr.icmp.checksum = 16w0;
+    standard_metadata.egress_spec = standard_metadata.ingress_port;
+  }
+
+  action forward_action_3(){
+    standard_metadata.egress_spec = 9w511;
+    exited = 1w1;
+  }
+
+  action ipv4_lpm_action_0(bit<48> mac_da,bit<48> mac_sa,bit<9> egress_port){
+    meta.mac_da = mac_da;
+    meta.mac_sa = mac_sa;
+    meta.egress_port = egress_port;
+  }
+
+  action ipv4_lpm_action_1(){
+    standard_metadata.egress_spec = 9w511;
+    exited = 1w1;
+  }
+
+
+// Table Definitions
+
+  table forward {
+    key = {
+      hdr.arp.isValid() : exact;
+      hdr.arp.oper : exact;
+      hdr.arp_ipv4.isValid() : exact;
+      hdr.ipv4.isValid() : exact;
+      hdr.icmp.isValid() : exact;
+      hdr.icmp.type : ternary;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+      forward_action_3;
+    }
+  }
+    
+  table ipv4_lpm {
+    key = {
+      meta.dst_ipv4 : exact;
+    }
+    actions = {
+      ipv4_lpm_action_0;
+      ipv4_lpm_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    meta.my_mac = 48w102030405;
+    if ((1w1 == exited)) {} else {
+      ipv4_lpm.apply();
+      forward.apply();
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Action Definitions
+
+
+// Table Definitions
+
+
+  apply {
+
+// Pipeline
+
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000061__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,243 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header tcp_t {
+
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  tcp_t tcp;
+}
+
+  
+
+// METADATA
+
+
+
+struct routing_metadata_t {
+
+  bit<32> nhop_ipv4;
+
+}
+struct my_metadata_t {
+  routing_metadata_t routing_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w6) : parse_tcp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_tcp {
+    packet.extract(hdr.tcp);
+    transition accept;
+  }
+    
+
+  state start {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> dmac;
+  bit<32> nhop_ipv4;
+  bit<9> port;
+
+
+// Action Definitions
+  action ecmp_group_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ecmp_group_action_1(bit<32> nhop_ipv4,bit<9> port){
+    meta.routing_metadata.nhop_ipv4 = nhop_ipv4;
+    standard_metadata.egress_spec = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action ecmp_group_action_2(){
+
+  }
+
+  action forward_action_0(bit<48> dmac){
+    hdr.ethernet.dstAddr = dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table ecmp_group {
+    key = {
+      hdr.ipv4.dstAddr : ternary;
+    }
+    actions = {
+      ecmp_group_action_0;
+      ecmp_group_action_1;
+      ecmp_group_action_2;
+    }
+  }
+    
+  table forward {
+    key = {
+      meta.routing_metadata.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    if (!((hdr.ipv4.isValid() ? 1w1 : 1w0) == 1w1)) {} else {
+      if (!(hdr.ipv4.ttl > 8w0)) {} else {
+        ecmp_group.apply();
+        forward.apply();
+      }
+
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> smac;
+
+
+// Action Definitions
+  action send_frame_action_0(bit<48> smac){
+    hdr.ethernet.srcAddr = smac;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+
+// Table Definitions
+
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    send_frame.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000062__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,374 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<32> srcAddr;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header tcp_t {
+  bit<16> srcPort;
+  bit<16> dstPort;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  tcp_t tcp;
+}
+
+  
+
+// METADATA
+
+
+
+struct ingress_metadata_t {
+
+  bit<32> nhop_ipv4;
+  bit<13> flowlet_map_index;
+  bit<32> flowlet_lasttime;
+  bit<16> flowlet_id;
+  bit<32> flow_ipg;
+  bit<14> ecmp_offset;
+
+}
+
+struct intrinsic_metadata_t {
+
+  bit<48> ingress_global_timestamp;
+
+}
+struct my_metadata_t {
+  ingress_metadata_t ingress_metadata;
+  intrinsic_metadata_t intrinsic_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w6) : parse_tcp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_tcp {
+    packet.extract(hdr.tcp);
+    transition accept;
+  }
+    
+
+  state start {
+    packet.extract(hdr.ethernet);
+    transition accept;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<13> DEVNULL_flowlet_id_lookup_flowlet_map;
+  bit<13> DEVNULL_flowlet_id_update_flowlet_id_index;
+  bit<16> DEVNULL_flowlet_id_update_flowlet_id_value;
+  bit<13> DEVNULL_flowlet_lasttime_lookup_flowlet_map;
+  bit<13> DEVNULL_flowlet_lasttime_lookup_flowlet_map_index;
+  bit<48> DEVNULL_flowlet_lasttime_lookup_flowlet_map_value;
+  bit<48> dmac;
+  bit<8> ecmp_base;
+  bit<8> ecmp_count;
+  bit<16> flowlet_id_lookup_flowlet_map;
+  bit<32> flowlet_lasttime_lookup_flowlet_map;
+  bit<13> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index;
+  bit<32> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_0;
+  bit<32> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_1;
+  bit<8> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_2;
+  bit<16> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_3;
+  bit<16> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_4;
+  bit<32> nhop_ipv4;
+  bit<9> port;
+  bit<14> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset;
+  bit<32> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_0;
+  bit<32> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_1;
+  bit<8> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_2;
+  bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_3;
+  bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_4;
+  bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_5;
+
+
+// Action Definitions
+  action ecmp_group_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ecmp_group_action_1(bit<8> ecmp_base,bit<8> ecmp_count){
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_0 = hdr.ipv4.srcAddr;
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_1 = hdr.ipv4.dstAddr;
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_2 = hdr.ipv4.protocol;
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_3 = hdr.tcp.srcPort;
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_4 = hdr.tcp.dstPort;
+    set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_5 = meta.ingress_metadata.flowlet_id;
+
+
+    meta.ingress_metadata.ecmp_offset = set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset;
+  }
+
+  action ecmp_group_action_2(){
+
+  }
+
+  action ecmp_nhop_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ecmp_nhop_action_1(bit<32> nhop_ipv4,bit<9> port){
+    meta.ingress_metadata.nhop_ipv4 = nhop_ipv4;
+    standard_metadata.egress_spec = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action ecmp_nhop_action_2(){
+
+  }
+
+  action flowlet_action_0(){
+    lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_0 = hdr.ipv4.srcAddr;
+    lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_1 = hdr.ipv4.dstAddr;
+    lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_2 = hdr.ipv4.protocol;
+    lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_3 = hdr.tcp.srcPort;
+    lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_4 = hdr.tcp.dstPort;
+
+
+    meta.ingress_metadata.flowlet_map_index = lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index;
+    DEVNULL_flowlet_id_lookup_flowlet_map = meta.ingress_metadata.flowlet_map_index;
+    meta.ingress_metadata.flowlet_id = flowlet_id_lookup_flowlet_map;
+    meta.ingress_metadata.flow_ipg = meta.intrinsic_metadata.ingress_global_timestamp[31:0];
+    DEVNULL_flowlet_lasttime_lookup_flowlet_map = meta.ingress_metadata.flowlet_map_index;
+    meta.ingress_metadata.flowlet_lasttime = flowlet_lasttime_lookup_flowlet_map;
+    meta.ingress_metadata.flow_ipg = (meta.ingress_metadata.flow_ipg - meta.ingress_metadata.flowlet_lasttime);
+    DEVNULL_flowlet_lasttime_lookup_flowlet_map_index = meta.ingress_metadata.flowlet_map_index;
+    DEVNULL_flowlet_lasttime_lookup_flowlet_map_value = meta.intrinsic_metadata.ingress_global_timestamp;
+  }
+
+  action flowlet_action_1(){
+
+  }
+
+  action forward_action_0(){
+    hdr.ethernet.dstAddr = dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+  action new_flowlet_action_0(){
+    meta.ingress_metadata.flowlet_id = (meta.ingress_metadata.flowlet_id + 16w1);
+    DEVNULL_flowlet_id_update_flowlet_id_index = meta.ingress_metadata.flowlet_map_index;
+    DEVNULL_flowlet_id_update_flowlet_id_value = meta.ingress_metadata.flowlet_id;
+  }
+
+  action new_flowlet_action_1(){
+
+  }
+
+
+// Table Definitions
+
+  table ecmp_group {
+    key = {
+      hdr.ipv4.dstAddr : ternary;
+    }
+    actions = {
+      ecmp_group_action_0;
+      ecmp_group_action_1;
+      ecmp_group_action_2;
+    }
+  }
+    
+  table ecmp_nhop {
+    key = {
+      meta.ingress_metadata.ecmp_offset : exact;
+    }
+    actions = {
+      ecmp_nhop_action_0;
+      ecmp_nhop_action_1;
+      ecmp_nhop_action_2;
+    }
+  }
+    
+  table flowlet {
+    key = {
+    }
+    actions = {
+      flowlet_action_0;
+      flowlet_action_1;
+    }
+  }
+    
+  table forward {
+    key = {
+      meta.ingress_metadata.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+  table new_flowlet {
+    key = {
+    }
+    actions = {
+      new_flowlet_action_0;
+      new_flowlet_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+
+    flowlet.apply();
+    if (!(meta.ingress_metadata.flow_ipg > 32w50000)) {} else {
+      new_flowlet.apply();
+    }
+
+    ecmp_group.apply();
+    ecmp_nhop.apply();
+    forward.apply();
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> smac;
+
+
+// Action Definitions
+  action send_frame_action_0(bit<48> smac){
+    hdr.ethernet.srcAddr = smac;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action send_frame_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+      send_frame_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    send_frame.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000063__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,274 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<32> srcAddr;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header tcp_t {
+
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  tcp_t tcp;
+}
+
+  
+
+// METADATA
+
+
+
+struct routing_metadata_t {
+
+  bit<32> nhop_ipv4;
+
+}
+struct my_metadata_t {
+  routing_metadata_t routing_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w6) : parse_tcp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_tcp {
+    packet.extract(hdr.tcp);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> dmac;
+  bit<32> idx;
+  bit<9> port;
+  bit<32> set_nhop;
+
+
+// Action Definitions
+  action count_table_action_0(bit<32> idx){
+
+  }
+
+  action count_table_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action count_table_action_2(){
+
+  }
+
+  action forward_action_0(bit<48> dmac){
+    hdr.ethernet.dstAddr = dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+  action ipv4_lpm_action_0(bit<32> set_nhop,bit<9> port){
+    meta.routing_metadata.nhop_ipv4 = set_nhop;
+    standard_metadata.egress_spec = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action ipv4_lpm_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ipv4_lpm_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table count_table {
+    key = {
+      hdr.ipv4.srcAddr : ternary;
+    }
+    actions = {
+      count_table_action_0;
+      count_table_action_1;
+      count_table_action_2;
+    }
+  }
+    
+  table forward {
+    key = {
+      meta.routing_metadata.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+  table ipv4_lpm {
+    key = {
+      hdr.ipv4.dstAddr : ternary;
+    }
+    actions = {
+      ipv4_lpm_action_0;
+      ipv4_lpm_action_1;
+      ipv4_lpm_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    count_table.apply();
+    ipv4_lpm.apply();
+    forward.apply();
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> smac;
+
+
+// Action Definitions
+  action send_frame_action_0(bit<48> smac){
+    hdr.ethernet.srcAddr = smac;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action send_frame_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+      send_frame_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    send_frame.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000064__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,340 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<32> srcAddr;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header tcp_t {
+  bit<16> srcPort;
+  bit<16> dstPort;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  tcp_t tcp;
+}
+
+  
+
+// METADATA
+
+
+
+struct custom_metadata_t {
+
+  bit<32> nhop_ipv4;
+  bit<16> hash_val2;
+  bit<16> hash_val1;
+  bit<16> count_val2;
+  bit<16> count_val1;
+
+}
+struct my_metadata_t {
+  custom_metadata_t custom_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w6) : parse_tcp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_tcp {
+    packet.extract(hdr.tcp);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count;
+  bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_index;
+  bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_value;
+  bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count;
+  bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_index;
+  bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_value;
+  bit<48> dmac;
+  bit<16> heavy_hitter_counter1_set_heavy_hitter_count;
+  bit<16> heavy_hitter_counter2_set_heavy_hitter_count;
+  bit<32> nhop_ipv4;
+  bit<9> port;
+  bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2;
+  bit<32> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_0;
+  bit<32> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_1;
+  bit<8> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_2;
+  bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_3;
+  bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_4;
+  bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1;
+  bit<32> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_0;
+  bit<32> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_1;
+  bit<8> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_2;
+  bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_3;
+  bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_4;
+
+
+// Action Definitions
+  action drop_heavy_hitter_table_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action drop_heavy_hitter_table_action_1(){
+
+  }
+
+  action forward_action_0(bit<48> dmac){
+    hdr.ethernet.dstAddr = dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+  action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){
+    meta.custom_metadata.nhop_ipv4 = nhop_ipv4;
+    standard_metadata.egress_spec = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action ipv4_lpm_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ipv4_lpm_action_2(){
+
+  }
+
+  action set_heavy_hitter_count_table_action_0(){
+    set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_0 = hdr.ipv4.srcAddr;
+    set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_1 = hdr.ipv4.dstAddr;
+    set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_2 = hdr.ipv4.protocol;
+    set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_3 = hdr.tcp.srcPort;
+    set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_4 = hdr.tcp.dstPort;
+
+
+    meta.custom_metadata.hash_val1 = set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1;
+    DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count = meta.custom_metadata.hash_val1;
+    meta.custom_metadata.count_val2 = heavy_hitter_counter1_set_heavy_hitter_count;
+    meta.custom_metadata.count_val2 = (meta.custom_metadata.count_val2 + 16w1);
+    DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_index = meta.custom_metadata.hash_val1;
+    DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_value = meta.custom_metadata.count_val2;
+    set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_0 = hdr.ipv4.srcAddr;
+    set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_1 = hdr.ipv4.dstAddr;
+    set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_2 = hdr.ipv4.protocol;
+    set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_3 = hdr.tcp.srcPort;
+    set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_4 = hdr.tcp.dstPort;
+
+
+    meta.custom_metadata.hash_val2 = set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2;
+    DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count = meta.custom_metadata.hash_val2;
+    meta.custom_metadata.count_val1 = heavy_hitter_counter2_set_heavy_hitter_count;
+    meta.custom_metadata.count_val1 = (meta.custom_metadata.count_val1 + 16w1);
+    DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_index = meta.custom_metadata.hash_val2;
+    DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_value = meta.custom_metadata.count_val1;
+  }
+
+  action set_heavy_hitter_count_table_action_1(){
+
+  }
+
+
+// Table Definitions
+
+  table drop_heavy_hitter_table {
+    key = {
+    }
+    actions = {
+      drop_heavy_hitter_table_action_0;
+      drop_heavy_hitter_table_action_1;
+    }
+  }
+    
+  table forward {
+    key = {
+      meta.custom_metadata.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+  table ipv4_lpm {
+    key = {
+      hdr.ipv4.dstAddr : ternary;
+    }
+    actions = {
+      ipv4_lpm_action_0;
+      ipv4_lpm_action_1;
+      ipv4_lpm_action_2;
+    }
+  }
+    
+  table set_heavy_hitter_count_table {
+    key = {
+    }
+    actions = {
+      set_heavy_hitter_count_table_action_0;
+      set_heavy_hitter_count_table_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+
+    set_heavy_hitter_count_table.apply();
+    if (!((meta.custom_metadata.count_val2 > 16w100) && (meta.custom_metadata.count_val1 > 16w100))) {
+      ipv4_lpm.apply();
+      forward.apply();
+    } else {
+      drop_heavy_hitter_table.apply();
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> smac;
+
+
+// Action Definitions
+  action send_frame_action_0(bit<48> smac){
+    hdr.ethernet.srcAddr = smac;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action send_frame_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+      send_frame_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    send_frame.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000065__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,222 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<16> etherType;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header udp_t {
+
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  udp_t udp;
+}
+
+  
+
+// METADATA
+
+
+
+struct intrinsic_metadata_t {
+
+  bit<16> mcast_grp;
+  bit<16> egress_rid;
+
+}
+struct my_metadata_t {
+  intrinsic_metadata_t intrinsic_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w17) : parse_udp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_udp {
+    packet.extract(hdr.udp);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<16> mcast_group;
+
+
+// Action Definitions
+  action set_mcg_action_0(bit<16> mcast_group){
+    meta.intrinsic_metadata.mcast_grp = mcast_group;
+  }
+
+  action set_mcg_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action set_mcg_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table set_mcg {
+    key = {
+      hdr.ipv4.dstAddr : exact;
+    }
+    actions = {
+      set_mcg_action_0;
+      set_mcg_action_1;
+      set_mcg_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+
+    set_mcg.apply();
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<32> dst_ip;
+
+
+// Action Definitions
+  action nat_table_action_0(bit<32> dst_ip){
+    hdr.ipv4.dstAddr = dst_ip;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action nat_table_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action nat_table_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table nat_table {
+    key = {
+      meta.intrinsic_metadata.egress_rid : exact;
+      hdr.ipv4.dstAddr : exact;
+    }
+    actions = {
+      nat_table_action_0;
+      nat_table_action_1;
+      nat_table_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    nat_table.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000066__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,387 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<16> totalLen;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header ndp_t {
+  bit<16> flags;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  ndp_t ndp;
+}
+
+  
+
+// METADATA
+
+
+
+struct meta_t {
+
+  bit<16> register_tmp;
+  bit<16> ndpflags;
+
+}
+
+struct routing_metadata_t {
+
+  bit<32> nhop_ipv4;
+
+}
+struct my_metadata_t {
+  meta_t meta;
+  routing_metadata_t routing_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w199) : parse_ndp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ndp {
+    packet.extract(hdr.ndp);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<9> DEVNULL_buffersense_readbuffer;
+  bit<9> DEVNULL_buffersense_set_dmac;
+  bit<9> DEVNULL_buffersense_setpriolow;
+  bit<9> DEVNULL_buffersense_setpriolow_index;
+  bit<16> DEVNULL_buffersense_setpriolow_value;
+  bit<16> buffersense_readbuffer;
+  bit<16> buffersense_set_dmac;
+  bit<16> buffersense_setpriolow;
+  bit<48> dmac;
+  bit<32> nhop_ipv4;
+  bit<9> port;
+
+
+// Action Definitions
+  action directtoprio_action_0(){
+    standard_metadata.egress_spec = 9w1;
+    meta.meta.ndpflags = hdr.ndp.flags;
+  }
+
+  action directtoprio_action_1(){
+
+  }
+
+  action forward_action_0(bit<48> dmac){
+    hdr.ethernet.dstAddr = dmac;
+    DEVNULL_buffersense_set_dmac = standard_metadata.egress_port;
+    meta.meta.register_tmp = buffersense_set_dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+  action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){
+    meta.routing_metadata.nhop_ipv4 = nhop_ipv4;
+    standard_metadata.egress_port = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255);
+  }
+
+  action ipv4_lpm_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ipv4_lpm_action_2(){
+
+  }
+
+  action readbuffersense_action_0(){
+    DEVNULL_buffersense_readbuffer = standard_metadata.egress_port;
+    meta.meta.register_tmp = buffersense_readbuffer;
+  }
+
+  action readbuffersense_action_1(){
+
+  }
+
+  action setprio_action_0(){
+    standard_metadata.egress_spec = 9w0;
+    DEVNULL_buffersense_setpriolow = standard_metadata.egress_port;
+    meta.meta.register_tmp = buffersense_setpriolow;
+    DEVNULL_buffersense_setpriolow_index = standard_metadata.egress_port;
+    DEVNULL_buffersense_setpriolow_value = (meta.meta.register_tmp + 16w1);
+  }
+
+  action setprio_action_1(){
+    hdr.ipv4.totalLen = 16w20;
+    standard_metadata.egress_spec = 9w1;
+  }
+
+  action setprio_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table directtoprio {
+    key = {
+      meta.meta.register_tmp : exact;
+    }
+    actions = {
+      directtoprio_action_0;
+      directtoprio_action_1;
+    }
+  }
+    
+  table forward {
+    key = {
+      meta.routing_metadata.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+  table ipv4_lpm {
+    key = {
+      hdr.ipv4.dstAddr : ternary;
+    }
+    actions = {
+      ipv4_lpm_action_0;
+      ipv4_lpm_action_1;
+      ipv4_lpm_action_2;
+    }
+  }
+    
+  table readbuffersense {
+    key = {
+      meta.meta.register_tmp : exact;
+    }
+    actions = {
+      readbuffersense_action_0;
+      readbuffersense_action_1;
+    }
+  }
+    
+  table setprio {
+    key = {
+      meta.meta.register_tmp : exact;
+    }
+    actions = {
+      setprio_action_0;
+      setprio_action_1;
+      setprio_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    if (!(1w1 == (hdr.ipv4.isValid() ? 1w1 : 1w0))) {
+      standard_metadata.egress_spec = 9w511;
+    } else {
+      if (!(hdr.ipv4.ttl > 8w0)) {
+        standard_metadata.egress_spec = 9w511;
+      } else {
+        ipv4_lpm.apply();
+        if (!(1w1 == (hdr.ndp.isValid() ? 1w1 : 1w0))) {
+          readbuffersense.apply();
+          setprio.apply();
+        } else {
+          if (!(hdr.ndp.flags > 16w1)) {
+            readbuffersense.apply();
+            setprio.apply();
+          } else {
+            directtoprio.apply();
+          }
+
+        }
+
+        forward.apply();
+      }
+
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<9> DEVNULL_buffersense_decreasereg;
+  bit<9> DEVNULL_buffersense_decreasereg_index;
+  bit<16> DEVNULL_buffersense_decreasereg_value;
+  bit<16> buffersense_decreasereg;
+  bit<48> smac;
+
+
+// Action Definitions
+  action dec_counter_action_0(){
+    DEVNULL_buffersense_decreasereg = standard_metadata.egress_port;
+    meta.meta.register_tmp = buffersense_decreasereg;
+    DEVNULL_buffersense_decreasereg_index = standard_metadata.egress_port;
+    DEVNULL_buffersense_decreasereg_value = ((meta.meta.register_tmp - 16w1) + (7w0 ++ standard_metadata.egress_spec));
+  }
+
+  action dec_counter_action_1(){
+
+  }
+
+  action dec_counter_action_2(){
+
+  }
+
+  action send_frame_action_0(bit<48> smac){
+    hdr.ethernet.srcAddr = smac;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action send_frame_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table dec_counter {
+    key = {
+      meta.meta.ndpflags : exact;
+    }
+    actions = {
+      dec_counter_action_0;
+      dec_counter_action_1;
+      dec_counter_action_2;
+    }
+  }
+    
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+      send_frame_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    dec_counter.apply();
+    send_frame.apply();
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000067__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,323 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<16> etherType;
+}
+header ipv4_t {
+  bit<8> protocol;
+}
+header paxos_t {
+  bit<16> vproposal;
+  bit<32> val;
+  bit<16> proposal;
+  bit<16> msgtype;
+  bit<32> inst;
+  bit<16> acpt;
+}
+header udp_t {
+  bit<16> dstPort;
+  bit<16> checksum;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  paxos_t paxos;
+  udp_t udp;
+}
+
+  
+
+// METADATA
+
+
+
+struct local_metadata_t {
+
+  bit<16> proposal;
+
+}
+struct my_metadata_t {
+  local_metadata_t local_metadata;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w17) : parse_udp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_paxos {
+    packet.extract(hdr.paxos);
+    transition accept;
+  }
+    
+
+  state parse_udp {
+    packet.extract(hdr.udp);
+    transition select(hdr.udp.dstPort){
+      (16w34952) : parse_paxos;
+      default : accept;
+    }
+
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<32> DEVNULL_acceptor_id;
+  bit<32> DEVNULL_acceptor_id_1a;
+  bit<32> DEVNULL_proposal_register_1a_index;
+  bit<16> DEVNULL_proposal_register_1a_value;
+  bit<32> DEVNULL_proposal_register_2a_index;
+  bit<16> DEVNULL_proposal_register_2a_value;
+  bit<32> DEVNULL_proposal_register_read_round;
+  bit<32> DEVNULL_val_register_1a;
+  bit<32> DEVNULL_val_register_index;
+  bit<32> DEVNULL_val_register_value;
+  bit<32> DEVNULL_vproposal_register_1a;
+  bit<32> DEVNULL_vproposal_register_2a_index;
+  bit<16> DEVNULL_vproposal_register_2a_value;
+  bit<16> acceptor_id;
+  bit<16> acceptor_id_1a;
+  bit<9> port;
+  bit<16> proposal_register_read_round;
+  bit<32> val_register_1a;
+  bit<16> vproposal_register_1a;
+
+
+// Action Definitions
+  action drop_tbl_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action drop_tbl_action_1(){
+
+  }
+
+  action fwd_tbl_action_0(bit<9> port){
+    standard_metadata.egress_spec = port;
+  }
+
+  action fwd_tbl_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action fwd_tbl_action_2(){
+
+  }
+
+  action paxos_tbl_action_0(){
+    DEVNULL_proposal_register_1a_index = hdr.paxos.inst;
+    DEVNULL_proposal_register_1a_value = hdr.paxos.proposal;
+    DEVNULL_vproposal_register_1a = hdr.paxos.inst;
+    hdr.paxos.vproposal = vproposal_register_1a;
+    DEVNULL_val_register_1a = hdr.paxos.inst;
+    hdr.paxos.val = val_register_1a;
+    DEVNULL_acceptor_id_1a = 32w0;
+    hdr.paxos.acpt = acceptor_id_1a;
+    hdr.udp.checksum = 16w0;
+  }
+
+  action paxos_tbl_action_1(){
+    DEVNULL_proposal_register_2a_index = hdr.paxos.inst;
+    DEVNULL_proposal_register_2a_value = hdr.paxos.proposal;
+    DEVNULL_vproposal_register_2a_index = hdr.paxos.inst;
+    DEVNULL_vproposal_register_2a_value = hdr.paxos.proposal;
+    DEVNULL_val_register_index = hdr.paxos.inst;
+    DEVNULL_val_register_value = hdr.paxos.val;
+    hdr.paxos.msgtype = 16w4;
+    hdr.paxos.vproposal = hdr.paxos.proposal;
+    DEVNULL_acceptor_id = 32w0;
+    hdr.paxos.acpt = acceptor_id;
+    hdr.udp.checksum = 16w0;
+  }
+
+  action paxos_tbl_action_2(){
+
+  }
+
+  action round_tbl_action_0(){
+    DEVNULL_proposal_register_read_round = hdr.paxos.inst;
+    meta.local_metadata.proposal = proposal_register_read_round;
+  }
+
+  action round_tbl_action_1(){
+
+  }
+
+
+// Table Definitions
+
+  table drop_tbl {
+    key = {
+    }
+    actions = {
+      drop_tbl_action_0;
+      drop_tbl_action_1;
+    }
+  }
+    
+  table fwd_tbl {
+    key = {
+      standard_metadata.ingress_port : exact;
+    }
+    actions = {
+      fwd_tbl_action_0;
+      fwd_tbl_action_1;
+      fwd_tbl_action_2;
+    }
+  }
+    
+  table paxos_tbl {
+    key = {
+      hdr.paxos.msgtype : exact;
+    }
+    actions = {
+      paxos_tbl_action_0;
+      paxos_tbl_action_1;
+      paxos_tbl_action_2;
+    }
+  }
+    
+  table round_tbl {
+    key = {
+    }
+    actions = {
+      round_tbl_action_0;
+      round_tbl_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    if (!((hdr.ipv4.isValid() ? 1w1 : 1w0) == 1w1)) {
+      if (!((hdr.paxos.isValid() ? 1w1 : 1w0) == 1w1)) {
+        standard_metadata.egress_spec = 9w511;
+      } else {
+        round_tbl.apply();
+        if (!(meta.local_metadata.proposal <= hdr.paxos.proposal)) {
+          drop_tbl.apply();
+        } else {
+          paxos_tbl.apply();
+        }
+
+      }
+
+    } else {
+      fwd_tbl.apply();
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Action Definitions
+
+
+// Table Definitions
+
+
+  apply {
+
+// Pipeline
+
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000068__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,180 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+}
+
+  
+
+// METADATA
+
+
+
+struct mymeta_t {
+
+  bit<8> f2;
+  bit<8> f1;
+
+}
+struct my_metadata_t {
+  mymeta_t mymeta;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<9> port;
+
+
+// Action Definitions
+  action t_ingress_1_action_0(){
+
+  }
+
+  action t_ingress_1_action_1(){
+    standard_metadata.egress_spec = port;
+  }
+
+  action t_ingress_2_action_0(){
+
+  }
+
+  action t_ingress_2_action_1(){
+    meta.mymeta.f1 = 8w1;
+  }
+
+
+// Table Definitions
+
+  table t_ingress_1 {
+    key = {
+      meta.mymeta.f1 : exact;
+    }
+    actions = {
+      t_ingress_1_action_0;
+      t_ingress_1_action_1;
+    }
+  }
+    
+  table t_ingress_2 {
+    key = {
+      meta.mymeta.f2 : exact;
+    }
+    actions = {
+      t_ingress_2_action_0;
+      t_ingress_2_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    t_ingress_1.apply();
+    t_ingress_2.apply();
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Action Definitions
+
+
+// Table Definitions
+
+
+  apply {
+
+// Pipeline
+
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000069__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,392 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header cpu_header_t {
+  bit<8> reason;
+  bit<64> preamble;
+  bit<8> if_index;
+  bit<8> device;
+}
+header ethernet_t {
+  bit<48> srcAddr;
+  bit<16> etherType;
+  bit<48> dstAddr;
+}
+header ipv4_t {
+  bit<8> ttl;
+  bit<16> totalLen;
+  bit<32> srcAddr;
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header tcp_t {
+  bit<16> srcPort;
+  bit<16> dstPort;
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  cpu_header_t cpu_header;
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  tcp_t tcp;
+}
+
+  
+
+// METADATA
+
+
+
+struct meta_t {
+
+  bit<16> tcp_sp;
+  bit<16> tcp_dp;
+  bit<16> tcpLength;
+  bit<32> nhop_ipv4;
+  bit<1> is_ext_if;
+  bit<32> ipv4_sa;
+  bit<32> ipv4_da;
+  bit<48> if_mac_addr;
+  bit<32> if_ipv4_addr;
+  bit<8> if_index;
+  bit<1> do_forward;
+
+}
+struct my_metadata_t {
+  meta_t meta;
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    meta.meta.ipv4_sa = hdr.ipv4.srcAddr;
+    meta.meta.ipv4_da = hdr.ipv4.dstAddr;
+    meta.meta.tcpLength = (hdr.ipv4.totalLen - 16w20);
+    transition select(hdr.ipv4.protocol){
+      (8w6) : parse_tcp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_tcp {
+    packet.extract(hdr.tcp);
+    transition accept;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> dmac;
+  bit<32> dstAddr;
+  bit<16> dstPort;
+  bit<32> ipv4_addr;
+  bit<1> is_ext;
+  bit<48> mac_addr;
+  bit<32> nhop_ipv4;
+  bit<9> port;
+
+
+// Action Definitions
+  action forward_action_0(bit<48> dmac){
+    hdr.ethernet.dstAddr = dmac;
+  }
+
+  action forward_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action forward_action_2(){
+
+  }
+
+  action if_info_action_0(bit<32> ipv4_addr,bit<48> mac_addr,bit<1> is_ext){
+    meta.meta.if_ipv4_addr = ipv4_addr;
+    meta.meta.if_mac_addr = mac_addr;
+    meta.meta.is_ext_if = is_ext;
+  }
+
+  action if_info_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action if_info_action_2(){
+
+  }
+
+  action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){
+    meta.meta.nhop_ipv4 = nhop_ipv4;
+    standard_metadata.egress_spec = port;
+    hdr.ipv4.ttl = (hdr.ipv4.ttl - 8w1);
+  }
+
+  action ipv4_lpm_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action ipv4_lpm_action_2(){
+
+  }
+
+  action nat_action_0(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action nat_action_1(){
+
+  }
+
+  action nat_action_2(){
+    meta.meta.do_forward = 1w0;
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action nat_action_3(){
+
+  }
+
+  action nat_action_4(bit<32> dstAddr,bit<16> dstPort){
+    meta.meta.do_forward = 1w1;
+    meta.meta.ipv4_da = dstAddr;
+    meta.meta.tcp_dp = dstPort;
+  }
+
+  action nat_action_5(){
+    meta.meta.do_forward = 1w1;
+  }
+
+  action nat_action_6(){
+
+  }
+
+
+// Table Definitions
+
+  table forward {
+    key = {
+      meta.meta.nhop_ipv4 : exact;
+    }
+    actions = {
+      forward_action_0;
+      forward_action_1;
+      forward_action_2;
+    }
+  }
+    
+  table if_info {
+    key = {
+      meta.meta.if_index : exact;
+    }
+    actions = {
+      if_info_action_0;
+      if_info_action_1;
+      if_info_action_2;
+    }
+  }
+    
+  table ipv4_lpm {
+    key = {
+      meta.meta.ipv4_da : exact;
+    }
+    actions = {
+      ipv4_lpm_action_0;
+      ipv4_lpm_action_1;
+      ipv4_lpm_action_2;
+    }
+  }
+    
+  table nat {
+    key = {
+      meta.meta.is_ext_if : exact;
+      hdr.ipv4.isValid() : exact;
+      hdr.tcp.isValid() : exact;
+      hdr.ipv4.srcAddr : ternary;
+      hdr.ipv4.dstAddr : ternary;
+      hdr.tcp.srcPort : ternary;
+      hdr.tcp.dstPort : ternary;
+    }
+    actions = {
+      nat_action_0;
+      nat_action_1;
+      nat_action_2;
+      nat_action_3;
+      nat_action_4;
+      nat_action_5;
+      nat_action_6;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    if_info.apply();
+    nat.apply();
+    if (!(meta.meta.do_forward == 1w1)) {} else {
+      if ((hdr.ipv4.ttl == 8w0)) {} else {
+        ipv4_lpm.apply();
+        forward.apply();
+      }
+
+    }
+
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<48> smac;
+
+
+// Action Definitions
+  action send_frame_action_0(bit<48> smac){
+    hdr.cpu_header.setInvalid();
+    hdr.ethernet.srcAddr = smac;
+    hdr.ipv4.srcAddr = meta.meta.ipv4_sa;
+    hdr.ipv4.dstAddr = meta.meta.ipv4_da;
+    hdr.tcp.srcPort = meta.meta.tcp_sp;
+    hdr.tcp.dstPort = meta.meta.tcp_dp;
+  }
+
+  action send_frame_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action send_frame_action_2(){
+
+  }
+
+  action send_to_cpu_action_0(){
+    hdr.cpu_header.setValid();
+    hdr.cpu_header.preamble = 64w0;
+    hdr.cpu_header.device = 8w0;
+    hdr.cpu_header.reason = 8w171;
+    hdr.cpu_header.if_index = meta.meta.if_index;
+  }
+
+  action send_to_cpu_action_1(){
+
+  }
+
+
+// Table Definitions
+
+  table send_frame {
+    key = {
+      standard_metadata.egress_port : exact;
+    }
+    actions = {
+      send_frame_action_0;
+      send_frame_action_1;
+      send_frame_action_2;
+    }
+  }
+    
+  table send_to_cpu {
+    key = {
+    }
+    actions = {
+      send_to_cpu_action_0;
+      send_to_cpu_action_1;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+    if (!(standard_metadata.instance_type == 32w0)) {
+      send_to_cpu.apply();
+    } else {
+      send_frame.apply();
+    }
+
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000070__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,200 @@
+#include <core.p4>
+#include <v1model.p4>  
+
+// HEADERS
+
+
+// Define header types
+
+header ethernet_t {
+  bit<16> etherType;
+}
+header ipv4_t {
+  bit<8> protocol;
+  bit<32> dstAddr;
+}
+header rtp_t {
+  bit<32> timestamp;
+}
+header udp_t {
+
+}
+
+// Assemble headers in a single struct
+struct my_headers_t {
+  ethernet_t ethernet;
+  ipv4_t ipv4;
+  rtp_t rtp;
+  udp_t udp;
+}
+
+  
+
+// METADATA
+
+
+struct my_metadata_t {
+
+
+}
+
+// PARSER
+
+parser MyParser(
+  packet_in packet,
+  out my_headers_t hdr,
+  inout my_metadata_t meta,
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Parser state machine
+
+
+  state parse_ethernet {
+    packet.extract(hdr.ethernet);
+    transition select(hdr.ethernet.etherType){
+      (16w2048) : parse_ipv4;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_ipv4 {
+    packet.extract(hdr.ipv4);
+    transition select(hdr.ipv4.protocol){
+      (8w17) : parse_udp;
+      default : accept;
+    }
+
+  }
+    
+
+  state parse_rtp {
+    packet.extract(hdr.rtp);
+    transition accept;
+  }
+    
+
+  state parse_udp {
+    packet.extract(hdr.udp);
+    transition parse_rtp;
+  }
+    
+
+  state start {
+
+    transition parse_ethernet;
+  }
+    
+}
+
+
+// INGRESS
+
+control MyIngress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+  bit<32> dst_ip;
+
+
+// Action Definitions
+  action schedule_table_action_0(){
+    standard_metadata.egress_spec = 9w1;
+    hdr.ipv4.dstAddr = dst_ip;
+  }
+
+  action schedule_table_action_1(){
+    standard_metadata.egress_spec = 9w511;
+  }
+
+  action schedule_table_action_2(){
+
+  }
+
+
+// Table Definitions
+
+  table schedule_table {
+    key = {
+      hdr.ipv4.dstAddr : exact;
+      hdr.rtp.timestamp : ternary;
+    }
+    actions = {
+      schedule_table_action_0;
+      schedule_table_action_1;
+      schedule_table_action_2;
+    }
+  }
+    
+
+  apply {
+
+// Pipeline
+
+    schedule_table.apply();
+  }
+}
+  
+
+// EGRESS
+
+control MyEgress (
+  inout my_headers_t hdr,
+  inout my_metadata_t meta, 
+  inout standard_metadata_t standard_metadata)
+{
+
+// Variable Definitions
+
+
+// Action Definitions
+
+
+// Table Definitions
+
+
+  apply {
+
+// Pipeline
+
+  }
+}
+  
+
+// OTHER
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+    }
+}
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000071__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,213 @@
+#include <core.p4>
+#include <v1model.p4>
+
+struct custom_metadata_t {
+    bit<32> nhop_ipv4;
+    bit<16> hash_val1;
+    bit<16> hash_val2;
+    bit<16> count_val1;
+    bit<16> count_val2;
+}
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+header ipv4_t {
+    bit<4>  version;
+    bit<4>  ihl;
+    bit<8>  diffserv;
+    bit<16> totalLen;
+    bit<16> identification;
+    bit<3>  flags;
+    bit<13> fragOffset;
+    bit<8>  ttl;
+    bit<8>  protocol;
+    bit<16> hdrChecksum;
+    bit<32> srcAddr;
+    bit<32> dstAddr;
+}
+
+header tcp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<3>  res;
+    bit<3>  ecn;
+    bit<6>  ctrl;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+struct metadata {
+    custom_metadata_t custom_metadata;
+}
+
+struct headers {
+
+    ethernet_t ethernet;
+    ipv4_t     ipv4;
+    tcp_t      tcp;
+}
+
+parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x800: parse_ipv4;
+            default: accept;
+        }
+    }
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            8w6: parse_tcp;
+            default: accept;
+        }
+    }
+    state parse_tcp {
+        packet.extract(hdr.tcp);
+        transition accept;
+    }
+    state start {
+        transition parse_ethernet;
+    }
+}
+
+control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    action rewrite_mac(bit<48> smac) {
+        hdr.ethernet.srcAddr = smac;
+    }
+    action _drop() {
+        mark_to_drop(standard_metadata);
+    }
+    table send_frame {
+        actions = {
+            rewrite_mac;
+            _drop;
+        }
+        key = {
+            standard_metadata.egress_port: exact;
+        }
+        size = 256;
+    }
+    apply {
+        send_frame.apply();
+    }
+}
+
+control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    register<bit<16>>(32w16) heavy_hitter_counter1;
+    register<bit<16>>(32w16) heavy_hitter_counter2;
+
+    action _drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action set_dmac(bit<48> dmac) {
+        hdr.ethernet.dstAddr = dmac;
+    }
+
+    action set_nhop(bit<32> nhop_ipv4, bit<9> port) {
+        meta.custom_metadata.nhop_ipv4 = nhop_ipv4;
+        standard_metadata.egress_spec = port;
+        hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255;
+    }
+    action set_heavy_hitter_count() {
+
+// Count the hash 1 for indexing
+        hash(meta.custom_metadata.hash_val1, HashAlgorithm.csum16, (bit<16>)0, { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.ipv4.protocol, hdr.tcp.srcPort, hdr.tcp.dstPort }, (bit<32>)16);
+
+// Read the value in the register with that index
+        heavy_hitter_counter1.read(meta.custom_metadata.count_val1, (bit<32>)meta.custom_metadata.hash_val1);
+
+// Incremet the value with 1
+        meta.custom_metadata.count_val1 = meta.custom_metadata.count_val1 + 16w1;
+
+// Write the value back to the register with that index
+        heavy_hitter_counter1.write((bit<32>)meta.custom_metadata.hash_val1, (bit<16>)meta.custom_metadata.count_val1);
+
+// Count the hash 2 for another indexing, similar to the first hash
+        hash(meta.custom_metadata.hash_val2, HashAlgorithm.crc16, (bit<16>)0, { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.ipv4.protocol, hdr.tcp.srcPort, hdr.tcp.dstPort }, (bit<32>)16);
+        heavy_hitter_counter2.read(meta.custom_metadata.count_val2, (bit<32>)meta.custom_metadata.hash_val2);
+        meta.custom_metadata.count_val2 = meta.custom_metadata.count_val2 + 16w1;
+        heavy_hitter_counter2.write((bit<32>)meta.custom_metadata.hash_val2, (bit<16>)meta.custom_metadata.count_val2);
+    }
+
+    table drop_heavy_hitter_table {
+        actions = {
+            _drop;
+        }
+        size = 1;
+    }
+    
+    table forward {
+        actions = {
+            set_dmac;
+            _drop;
+        }
+        key = {
+            meta.custom_metadata.nhop_ipv4: exact;
+        }
+        size = 512;
+    }
+    
+    table ipv4_lpm {
+        actions = {
+            set_nhop;
+
+// Set next hop
+            _drop;
+        }
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        size = 1024;
+    }
+    
+    table set_heavy_hitter_count_table {
+        actions = {
+            set_heavy_hitter_count;
+        }
+        size = 1;
+    }
+
+    apply {
+        set_heavy_hitter_count_table.apply();
+
+        if (meta.custom_metadata.count_val1 > 16w100 && meta.custom_metadata.count_val2 > 16w100) {
+            drop_heavy_hitter_table.apply();
+        }
+        else {
+            ipv4_lpm.apply();
+            forward.apply();
+        }
+    }
+}
+
+control DeparserImpl(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.tcp);
+    }
+}
+
+control verifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+        verify_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+control computeChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+        update_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

individual_files/000072__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,177 @@
+#include <core.p4>
+#define V1MODEL_VERSION 20200408
+#include <v1model.p4>
+
+struct ghost_t {
+    bit<1>  assign;
+    bit<1>  alloc;
+    bit<1>  deref;
+}
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+header icmp_t {
+    bit<16> typeCode;
+    bit<16> hdrChecksum;
+}
+
+header ipv4_t {
+    bit<4>  version;
+    bit<4>  ihl;
+    bit<8>  diffserv;
+    bit<16> totalLen;
+    bit<16> identification;
+    bit<3>  flags;
+    bit<13> fragOffset;
+    bit<8>  ttl;
+    bit<8>  protocol;
+    bit<16> hdrChecksum;
+    bit<32> srcAddr;
+    bit<32> dstAddr;
+}
+
+header ipv6_t {
+    bit<4>   version;
+    bit<8>   trafficClass;
+    bit<20>  flowLabel;
+    bit<16>  payloadLen;
+    bit<8>   nextHdr;
+    bit<8>   hopLimit;
+    bit<128> srcAddr;
+    bit<128> dstAddr;
+}
+
+header tcp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<32> seqNo;
+    bit<32> ackNo;
+    bit<4>  dataOffset;
+    bit<4>  res;
+    bit<8>  flags;
+    bit<16> window;
+    bit<16> checksum;
+    bit<16> urgentPtr;
+}
+
+header udp_t {
+    bit<16> srcPort;
+    bit<16> dstPort;
+    bit<16> length_;
+    bit<16> checksum;
+}
+
+header vlan_tag_t {
+    bit<3>  pcp;
+    bit<1>  cfi;
+    bit<12> vid;
+    bit<16> etherType;
+}
+
+struct metadata {
+    bit<16> ptr;
+    ghost_t spec;
+}
+
+struct headers {
+    ethernet_t ethernet;
+    icmp_t     icmp;
+    ipv4_t     ipv4;
+    ipv6_t     ipv6;
+    tcp_t      tcp;
+    udp_t      udp;
+    vlan_tag_t vlan_tag;
+}
+
+parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".start") state start {
+        packet.extract(hdr.ethernet);
+        transition accept;
+    }
+}
+
+control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    action alloc () {
+        meta.spec.alloc = 1w1;
+    }
+    action unalloc () {
+        meta.spec.alloc = 1w0;
+    }
+    action drop_ () {
+        mark_to_drop(standard_metadata);
+    }
+    action fwd (bit<9> port) {
+        standard_metadata.egress_spec = port;
+        meta.spec.deref = 1w1;
+    }
+    action assign_(bit<16> ptr){
+        meta.ptr = ptr;
+        meta.spec.assign = 1w1;
+    }
+    table assign {
+        key = {
+            hdr.ethernet.dstAddr : exact;
+        }
+        actions = {
+           assign_;
+           drop_;
+        }
+    }
+    table allocator {
+        key = {
+            meta.ptr : exact;
+        }
+        actions = {
+          alloc;
+          @defaultonly unalloc;
+        }
+        const default_action = unalloc;
+    }
+    table deref {
+        key = {
+            meta.ptr : exact;
+        }
+        actions = {
+            fwd;
+            @defaultonly drop_;
+        }
+        const default_action = drop_;
+    }
+
+    apply {
+      meta.spec.assign = 1w0;
+      meta.spec.alloc = 1w0;
+      meta.spec.deref = 1w0;
+
+      assign.apply();
+      allocator.apply();
+      deref.apply();
+      assert(meta.spec.assign == 1w0 || meta.spec.alloc == 1w1);
+      assert(meta.spec.deref == 1w0 || meta.spec.alloc == 1w1);
+      standard_metadata.egress_spec = 9w511;
+    }
+}
+
+control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    apply {}
+}
+
+control DeparserImpl(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+    }
+}
+
+control verifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {}
+}
+
+control computeChecksum(inout headers hdr, inout metadata meta) {
+    apply {}
+}
+
+V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

individual_files/000073__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,279 @@
+
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+
+/*  Define the headers the program will recognize */
+
+
+typedef bit<48>  mac_addr_t;
+typedef bit<32>  ipv4_addr_t;
+typedef bit<9>   port_id_t; 
+
+header ethernet_t {
+    mac_addr_t dstAddr;
+    mac_addr_t srcAddr;
+    bit<16>    etherType;
+}
+
+header ipv4_t {
+    bit<4>       version;
+    bit<4>       ihl;
+    bit<8>       diffserv;
+    bit<16>      totalLen;
+    bit<16>      identification;
+    bit<3>       flags;
+    bit<13>      fragOffset;
+    bit<8>       ttl;
+    bit<8>       protocol;
+    bit<16>      hdrChecksum;
+    ipv4_addr_t  srcAddr;
+    ipv4_addr_t  dstAddr;
+}
+
+
+
+header arp_t {
+    bit<16> htype;
+    bit<16> ptype;
+    bit<8>  hlen;
+    bit<8>  plen;
+    bit<16> oper;
+}
+
+header arp_ipv4_t {
+    mac_addr_t  sha;
+    ipv4_addr_t spa;
+    mac_addr_t  tha;
+    ipv4_addr_t tpa;
+}
+
+
+
+header icmp_t {
+    bit<8>  type;
+    bit<8>  code;
+    bit<16> checksum;
+}
+    
+
+/* Assemble headers in a single struct */
+struct my_headers_t {
+    ethernet_t   ethernet;
+    arp_t        arp;
+    arp_ipv4_t   arp_ipv4;
+    ipv4_t       ipv4;
+    icmp_t       icmp;
+}
+
+
+/*  Define the global metadata for your program */
+
+struct my_metadata_t {
+    ipv4_addr_t dst_ipv4;
+    mac_addr_t  mac_da;
+    mac_addr_t  mac_sa;
+    port_id_t   egress_port;
+    mac_addr_t  my_mac;
+}
+
+
+parser MyParser(
+    packet_in             packet,
+    out   my_headers_t    hdr,
+    inout my_metadata_t   meta,
+    inout standard_metadata_t standard_metadata)
+{
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x0800 : parse_ipv4;
+            16w0x0806  : parse_arp;
+            default        : accept;
+        }
+    }
+
+    state parse_arp {
+        packet.extract(hdr.arp);
+        transition select(hdr.arp.htype, hdr.arp.ptype,
+                          hdr.arp.hlen,  hdr.arp.plen) {
+            (16w0x0001, 16w0x0800,
+             8w6,  8w4) : parse_arp_ipv4;
+            default : accept;
+        }
+    }
+
+    state parse_arp_ipv4 {
+        packet.extract(hdr.arp_ipv4);
+        meta.dst_ipv4 = hdr.arp_ipv4.tpa;
+        transition accept;
+    }            
+
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        meta.dst_ipv4 = hdr.ipv4.dstAddr;
+        transition select(hdr.ipv4.protocol) {
+            8w0x01 : parse_icmp;
+            default      : accept;
+        }
+    }
+
+    state parse_icmp {
+        packet.extract(hdr.icmp);
+        transition accept;
+    }    
+}
+
+
+control MyVerifyChecksum(
+    inout my_headers_t   hdr,
+    inout my_metadata_t  meta)
+{
+    apply {     }
+}
+
+
+control MyIngress(
+    inout my_headers_t     hdr,
+    inout my_metadata_t    meta,
+    inout standard_metadata_t  standard_metadata)
+{
+    action drop() {
+        mark_to_drop(standard_metadata);
+        exit;
+    }
+    
+    action set_dst_info(mac_addr_t mac_da,
+                        mac_addr_t mac_sa,
+                        port_id_t  egress_port)
+    {
+        meta.mac_da      = mac_da;
+        meta.mac_sa      = mac_sa;
+        meta.egress_port = egress_port;
+    }
+    
+    table ipv4_lpm {
+        key     = { meta.dst_ipv4 : lpm; }
+        actions = { set_dst_info; drop;  }
+        default_action = drop();
+    }
+
+    action forward_ipv4() {
+        hdr.ethernet.dstAddr = meta.mac_da;
+        hdr.ethernet.srcAddr = meta.mac_sa;
+        hdr.ipv4.ttl         = hdr.ipv4.ttl - 8w1;
+        
+        standard_metadata.egress_spec = meta.egress_port;
+    }
+
+    action send_arp_reply() {
+        hdr.ethernet.dstAddr = hdr.arp_ipv4.sha;
+        hdr.ethernet.srcAddr = meta.mac_da;
+        
+        hdr.arp.oper         = 16w2;
+        
+        hdr.arp_ipv4.tha     = hdr.arp_ipv4.sha;
+        hdr.arp_ipv4.tpa     = hdr.arp_ipv4.spa;
+        hdr.arp_ipv4.sha     = meta.mac_da;
+        hdr.arp_ipv4.spa     = meta.dst_ipv4;
+
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+    }
+
+    action send_icmp_reply() {
+        mac_addr_t   tmp_mac;
+        ipv4_addr_t  tmp_ip;
+
+        tmp_mac              = hdr.ethernet.dstAddr;
+        hdr.ethernet.dstAddr = hdr.ethernet.srcAddr;
+        hdr.ethernet.srcAddr = tmp_mac;
+
+        tmp_ip               = hdr.ipv4.dstAddr;
+        hdr.ipv4.dstAddr     = hdr.ipv4.srcAddr;
+        hdr.ipv4.srcAddr     = tmp_ip;
+
+        hdr.icmp.type        = 8w0;
+        hdr.icmp.checksum    = 16w0;
+
+// For now
+
+        standard_metadata.egress_spec = standard_metadata.ingress_port;
+    }
+
+    table forward {
+        key = {
+            hdr.arp.isValid()      : exact;
+            hdr.arp.oper           : ternary;
+            hdr.arp_ipv4.isValid() : exact;
+            hdr.ipv4.isValid()     : exact;
+            hdr.icmp.isValid()     : exact;
+            hdr.icmp.type          : ternary;
+        }
+        actions = {
+            forward_ipv4;
+            send_arp_reply;
+            send_icmp_reply;
+            drop;
+        }
+        const default_action = drop();
+        const entries = {
+            ( true, 16w1, true, false, false, _  ) :
+                                                         send_arp_reply();
+            ( false, _,               false, true, false, _  ) :
+                                                         forward_ipv4();
+            ( false, _,               false, true, true, 8w8 ) :
+                                                         send_icmp_reply();
+        }
+    }
+    
+    apply {
+        meta.my_mac = 48w0x000102030405;
+        ipv4_lpm.apply();
+        forward.apply();
+    }
+}
+
+
+control MyEgress(
+    inout my_headers_t        hdr,
+    inout my_metadata_t       meta,
+    inout standard_metadata_t standard_metadata) {
+    apply {    }
+}
+
+
+control MyComputeChecksum(
+    inout my_headers_t  hdr,
+    inout my_metadata_t meta)
+{
+    apply {   }
+}
+
+
+control MyDeparser(
+    packet_out      packet,
+    in my_headers_t hdr)
+{
+    apply {
+        packet.emit(hdr.ethernet);
+
+/* ARP Case */
+        packet.emit(hdr.arp);
+        packet.emit(hdr.arp_ipv4);
+
+/* IPv4 case */
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.icmp);
+    }
+}
+
+V1Switch(
+    MyParser(),
+    MyVerifyChecksum(),
+    MyIngress(),
+    MyEgress(),
+    MyComputeChecksum(),
+    MyDeparser()
+) main;

individual_files/000074__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,246 @@
+#include <core.p4>
+#include <v1model.p4>
+
+
+
+struct meta_t {
+    bit<16> register_tmp;
+    bit<16> ndpflags;
+}
+
+struct routing_metadata_t {
+    bit<32> nhop_ipv4;
+}
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+header ipv4_t {
+    bit<4>  version;
+    bit<4>  ihl;
+    bit<8>  diffserv;
+    bit<16> totalLen;
+    bit<16> identification;
+    bit<3>  flags;
+    bit<13> fragOffset;
+    bit<8>  ttl;
+    bit<8>  protocol;
+    bit<16> hdrChecksum;
+    bit<32> srcAddr;
+    bit<32> dstAddr;
+}
+
+header ndp_t {
+    bit<16> flags;
+    bit<16> checksum;
+    bit<32> sport;
+    bit<32> dport;
+    bit<32> seqpull;
+    bit<32> pacerecho;
+}
+
+struct metadata {
+    @name(".meta") 
+    meta_t             meta;
+    @name(".routing_metadata") 
+    routing_metadata_t routing_metadata;
+}
+
+struct headers {
+    @name(".ethernet") 
+    ethernet_t ethernet;
+    @name(".ipv4") 
+    ipv4_t     ipv4;
+    @name(".ndp") 
+    ndp_t      ndp;
+}
+
+parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".parse_ethernet") state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x800: parse_ipv4;
+            default: accept;
+        }
+    }
+    @name(".parse_ipv4") state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition select(hdr.ipv4.protocol) {
+            8w199: parse_ndp;
+            default: accept;
+        }
+    }
+    @name(".parse_ndp") state parse_ndp {
+        packet.extract(hdr.ndp);
+        transition accept;
+    }
+    @name(".start") state start {
+        transition parse_ethernet;
+    }
+}
+
+control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".buffersense") register<bit<16>>(32w4) buffersense;
+    @name(".decreasereg") action decreasereg() {
+        buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port);
+        buffersense.write((bit<32>)standard_metadata.egress_port, (bit<16>)(meta.meta.register_tmp - 16w1 + (bit<16>)standard_metadata.egress_spec));
+    }
+    @name(".cont") action cont() {
+    }
+    @name(".rewrite_mac") action rewrite_mac(bit<48> smac) {
+        hdr.ethernet.srcAddr = smac;
+    }
+    @name("._drop") action _drop() {
+        mark_to_drop(standard_metadata);
+    }
+    @name(".dec_counter") table dec_counter {
+        actions = {
+            decreasereg;
+            cont;
+        }
+        key = {
+            meta.meta.ndpflags: ternary;
+        }
+        size = 2;
+    }
+    @name(".send_frame") table send_frame {
+        actions = {
+            rewrite_mac;
+            _drop;
+        }
+        key = {
+            standard_metadata.egress_port: exact;
+        }
+        size = 256;
+    }
+    apply {
+        dec_counter.apply();
+        send_frame.apply();
+    }
+}
+
+control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".buffersense") register<bit<16>>(32w4) buffersense;
+    @name(".directpriohigh") action directpriohigh() {
+        standard_metadata.egress_spec = 9w1;
+        meta.meta.ndpflags = hdr.ndp.flags;
+    }
+    @name(".set_dmac") action set_dmac(bit<48> dmac) {
+        hdr.ethernet.dstAddr = dmac;
+        buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port);
+    }
+    @name("._drop") action _drop() {
+        mark_to_drop(standard_metadata);
+    }
+    @name(".set_nhop") action set_nhop(bit<32> nhop_ipv4, bit<9> port) {
+        meta.routing_metadata.nhop_ipv4 = nhop_ipv4;
+        standard_metadata.egress_port = port;
+        hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255;
+    }
+    @name(".readbuffer") action readbuffer() {
+        buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port);
+    }
+    @name(".setpriolow") action setpriolow() {
+        standard_metadata.egress_spec = 9w0;
+        buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port);
+        buffersense.write((bit<32>)standard_metadata.egress_port, (bit<16>)(meta.meta.register_tmp + 16w1));
+    }
+    @name(".setpriohigh") action setpriohigh() {
+        truncate((bit<32>)32w54);
+        hdr.ipv4.totalLen = 16w20;
+        standard_metadata.egress_spec = 9w1;
+    }
+    @name(".directtoprio") table directtoprio {
+        actions = {
+            directpriohigh;
+        }
+        key = {
+            meta.meta.register_tmp: ternary;
+        }
+        size = 2;
+    }
+    @name(".forward") table forward {
+        actions = {
+            set_dmac;
+            _drop;
+        }
+        key = {
+            meta.routing_metadata.nhop_ipv4: exact;
+        }
+        size = 512;
+    }
+    @name(".ipv4_lpm") table ipv4_lpm {
+        actions = {
+            set_nhop;
+            _drop;
+        }
+        key = {
+            hdr.ipv4.dstAddr: lpm;
+        }
+        size = 1024;
+    }
+    @name(".readbuffersense") table readbuffersense {
+        actions = {
+            readbuffer;
+        }
+        key = {
+            meta.meta.register_tmp: ternary;
+        }
+        size = 2;
+    }
+    @name(".setprio") table setprio {
+        actions = {
+            setpriolow;
+            setpriohigh;
+        }
+        key = {
+            meta.meta.register_tmp: ternary;
+        }
+        size = 2;
+    }
+    apply {
+        if (hdr.ipv4.isValid()) {
+          if (hdr.ipv4.ttl > 8w0) {
+            ipv4_lpm.apply();
+            if (hdr.ndp.isValid()) {
+              if (hdr.ndp.flags > 16w1) {
+                directtoprio.apply();
+              } else {
+                readbuffersense.apply();
+                setprio.apply();
+              }
+            }
+            else {
+              readbuffersense.apply();
+              setprio.apply();
+            }
+            forward.apply();
+          }
+        }
+    }
+}
+
+control DeparserImpl(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+        packet.emit(hdr.ipv4);
+        packet.emit(hdr.ndp);
+    }
+}
+
+control verifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+        verify_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+control computeChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+        update_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16);
+    }
+}
+
+V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

individual_files/000075__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,98 @@
+#include <core.p4>
+#include <v1model.p4>
+
+struct intrinsic_metadata_t {
+    bit<4>  mcast_grp;
+    bit<4>  egress_rid;
+    bit<32> lf_field_list;
+    bit<16> resubmit_flag;
+}
+
+struct mymeta_t {
+    bit<8> f1;
+}
+
+header ethernet_t {
+    bit<48> dstAddr;
+    bit<48> srcAddr;
+    bit<16> etherType;
+}
+
+struct metadata {
+    @name(".mymeta") 
+    mymeta_t mymeta;
+}
+
+struct headers {
+    @name(".ethernet") 
+    ethernet_t ethernet;
+}
+
+parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".parse_ethernet") state parse_ethernet {
+        packet.extract(hdr.ethernet);
+        transition accept;
+    }
+    @name(".start") state start {
+        transition parse_ethernet;
+    }
+}
+
+control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    apply {
+    }
+}
+
+control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name("._nop") action _nop() {
+    }
+    @name(".set_port") action set_port(bit<9> port) {
+        standard_metadata.egress_spec = port;
+    }
+    @name("._resubmit") action _resubmit() {
+        meta.mymeta.f1 = 8w1;
+
+    }
+    @name(".t_ingress_1") table t_ingress_1 {
+        actions = {
+            _nop;
+            set_port;
+        }
+        key = {
+            meta.mymeta.f1: exact;
+        }
+        size = 128;
+    }
+    @name(".t_ingress_2") table t_ingress_2 {
+        actions = {
+            _nop;
+            _resubmit;
+        }
+        key = {
+            meta.mymeta.f1: exact;
+        }
+        size = 128;
+    }
+    apply {
+        t_ingress_1.apply();
+        t_ingress_2.apply();
+    }
+}
+
+control DeparserImpl(packet_out packet, in headers hdr) {
+    apply {
+        packet.emit(hdr.ethernet);
+    }
+}
+
+control verifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+    }
+}
+
+control computeChecksum(inout headers hdr, inout metadata meta) {
+    apply {
+    }
+}
+
+V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

individual_files/000076__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,122 @@
+#include <core.p4>
+#define V1MODEL_VERSION 20200408
+#include <v1model.p4>
+
+struct ingress_metadata_t {
+}
+
+header h_t {
+   bit<16> value;
+}
+
+struct metadata {
+    ingress_metadata_t ing_metadata;
+}
+
+struct headers {
+    h_t h0;
+    h_t h1;
+    h_t h2;
+    h_t h3;
+    h_t h4;
+}
+
+parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    @name(".start") state start {
+        packet.extract(hdr.h0);
+    }
+}
+
+control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    action drop_() {
+        mark_to_drop(standard_metadata);
+    }
+    action validate_h1(bit<16> value) {
+        hdr.h1.setValid();
+        hdr.h1.value = value;
+    }
+    action validate_h2(bit<16> value) {
+        hdr.h2.setValid();
+        hdr.h2.value = value;
+    }
+    action validate_h3(bit<16> value) {
+        hdr.h3.setValid();
+        hdr.h3.value = value;
+    }
+    action use_h1_h2_h3() {
+        hdr.h4.setValid();
+        hdr.h4.value =
+           (hdr.h1.value & (hdr.h2.value | hdr.h3.value)) -
+           ((hdr.h1.value | (hdr.h2.value & hdr.h3.value)));
+        assert(hdr.h4.value <= (hdr.h1.value & (hdr.h2.value | hdr.h3.value)));
+
+// underflow protection
+
+    }
+    table t1 {
+        key = {
+            hdr.h0.value: exact;
+        }
+        actions = {
+           validate_h1;
+           drop_;
+        }
+    }
+    table t2 {
+        key = {
+            hdr.h0.value: exact;
+        }
+        actions = {
+           validate_h2;
+           drop_;
+        }
+    }
+    table t3 {
+        key = {
+            hdr.h0.value: exact;
+        }
+        actions = {
+            validate_h3;
+            drop_;
+        }
+    }
+    table t4 {
+       key = {
+         hdr.h0.value: exact;
+       }
+       actions = {
+         use_h1_h2_h3;
+         drop_;
+      }
+    }
+    apply {
+      hdr.h1.setInvalid();
+      hdr.h2.setInvalid();
+      hdr.h3.setInvalid();
+      hdr.h4.setInvalid();
+      t1.apply();
+      t2.apply();
+      t3.apply();
+      t4.apply();
+      standard_metadata.egress_spec = 9w511;
+    }
+}
+
+control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
+    apply {}
+}
+
+control DeparserImpl(packet_out packet, in headers hdr) {
+    apply {
+    }
+}
+
+control verifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {}
+}
+
+control computeChecksum(inout headers hdr, inout metadata meta) {
+    apply {}
+}
+
+V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

individual_files/000077__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,186 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define TYPE_IPV4 16w0x800;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header ipv6_t {
+    bit<4>   version;
+    bit<8>   trafficClass;
+    bit<20>  flowLabel;
+    bit<16>  payloadLen;
+    bit<8>   nextHdr;
+    bit<8>   hopLimit;
+    bit<128> srcAddr;
+    bit<128> dstAddr;
+}
+
+struct metadata {
+    bit<1> l3_admit;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+    ipv6_t       ipv6;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+    state parse_ipv6 {
+        packet.extract(hdr.ipv6);
+        transition accept;
+    }
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x0800: parse_ipv4;
+            default : reject;
+        }
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action packet_type(bit<1> is_l3) {
+        meta.l3_admit = is_l3;
+    }
+
+    table l2 {
+        key = {
+            hdr.ethernet.srcAddr: exact;
+        }
+        actions = {
+            drop;
+            NoAction;
+        }
+    }
+
+    action ctrl() {
+        standard_metadata.egress_spec = 9w510;
+
+// or whatever the controller port number is
+    }
+
+    table l3 {
+        key = { hdr.ipv4.ttl : exact; }
+        actions = { drop; NoAction; }
+    }
+
+    table punt {
+        key = { hdr.ethernet.srcAddr: exact;
+                hdr.ethernet.dstAddr: exact;
+                hdr.ipv4.srcAddr: exact;
+                hdr.ipv4.ttl : exact;
+                hdr.ipv4.dstAddr : exact; }
+        actions = { ctrl; NoAction; }
+    }
+
+    apply {
+        standard_metadata.egress_spec = 9w0;
+        l2.apply();
+        l3.apply();
+        punt.apply();
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000078__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,172 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define TYPE_IPV4 16w0x800;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header ipv6_t {
+    bit<4>   version;
+    bit<8>   trafficClass;
+    bit<20>  flowLabel;
+    bit<16>  payloadLen;
+    bit<8>   nextHdr;
+    bit<8>   hopLimit;
+    bit<128> srcAddr;
+    bit<128> dstAddr;
+}
+
+struct metadata {
+    bit<1> l3_admit;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+    ipv6_t       ipv6;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+    state parse_ipv6 {
+        packet.extract(hdr.ipv6);
+        transition accept;
+    }
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x0800: parse_ipv4;
+            default : reject;
+        }
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action packet_type(bit<1> is_l3) {
+        meta.l3_admit = is_l3;
+    }
+
+    table get_type {
+        key = {
+            hdr.ethernet.etherType: exact;
+        }
+        actions = {
+            packet_type;
+            drop;
+        }
+    }
+
+    action fwd_(bit<9> port) {
+        standard_metadata.egress_spec = port;
+    }
+
+    table fwd {
+        key = { meta.l3_admit : exact ; hdr.ipv4.dstAddr : lpm; }
+        actions = { fwd_; drop; NoAction; }
+    }
+    apply {
+        get_type.apply();
+        fwd.apply();
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;

individual_files/000079__raw-repositories__cornell-netlab__capisce.p4

@@ -0,0 +1,191 @@
+#include <core.p4>
+#include <v1model.p4>
+
+#define TYPE_IPV4 16w0x800;
+
+
+
+typedef bit<9>  egressSpec_t;
+typedef bit<48> macAddr_t;
+typedef bit<32> ip4Addr_t;
+
+header ethernet_t {
+    macAddr_t dstAddr;
+    macAddr_t srcAddr;
+    bit<16>   etherType;
+}
+
+header ipv4_t {
+    bit<4>    version;
+    bit<4>    ihl;
+    bit<8>    diffserv;
+    bit<16>   totalLen;
+    bit<16>   identification;
+    bit<3>    flags;
+    bit<13>   fragOffset;
+    bit<8>    ttl;
+    bit<8>    protocol;
+    bit<16>   hdrChecksum;
+    ip4Addr_t srcAddr;
+    ip4Addr_t dstAddr;
+}
+
+header ipv6_t {
+    bit<4>   version;
+    bit<8>   trafficClass;
+    bit<20>  flowLabel;
+    bit<16>  payloadLen;
+    bit<8>   nextHdr;
+    bit<8>   hopLimit;
+    bit<128> srcAddr;
+    bit<128> dstAddr;
+}
+
+struct metadata {
+    bit<1> is_v4;
+}
+
+struct headers {
+    ethernet_t   ethernet;
+    ipv4_t       ipv4;
+    ipv6_t       ipv6;
+    ipv4_t       inner_ipv4;
+    ipv6_t       inner_ipv6;
+}
+
+
+
+parser MyParser(packet_in packet,
+                out headers hdr,
+                inout metadata meta,
+                inout standard_metadata_t standard_metadata) {
+    state parse_ipv4 {
+        packet.extract(hdr.ipv4);
+        transition accept;
+    }
+
+    state parse_ipv6 {
+        packet.extract(hdr.ipv6);
+        transition accept;
+    }
+
+    state start {
+        packet.extract(hdr.ethernet);
+        transition select(hdr.ethernet.etherType) {
+            16w0x0800: parse_ipv4;
+            16w0x86DD: parse_ipv6;
+            default : reject;
+        }
+    }
+}
+
+
+
+
+control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
+    apply {  }
+}
+
+
+
+
+control MyIngress(inout headers hdr,
+                  inout metadata meta,
+                  inout standard_metadata_t standard_metadata) {
+    action drop() {
+        mark_to_drop(standard_metadata);
+    }
+
+    action packet_type(bit<1> version) {
+        meta.is_v4 = version;
+    }
+
+    action encap_v4(){
+        hdr.inner_ipv4.setValid();
+
+    }
+
+    action encap_v6() {
+        hdr.inner_ipv6.setValid();
+
+    }
+
+    table get_type {
+        key = {
+            hdr.ethernet.etherType: exact;
+        }
+        actions = {
+            packet_type;
+        }
+    }
+
+    table ipv4_encap {
+          key = { hdr.ethernet.etherType : exact; }
+          actions = { encap_v4; NoAction; }
+    }
+
+    table ipv6_encap {
+          key = { hdr.ethernet.etherType : exact; }
+          actions = { encap_v6; NoAction; }
+    }
+    apply {
+        hdr.inner_ipv6.setInvalid();
+        hdr.inner_ipv4.setInvalid();
+        ipv4_encap.apply();
+        ipv6_encap.apply();
+
+        assert((!hdr.ipv4.isValid()) || (!hdr.inner_ipv6.isValid()));
+        assert((!hdr.ipv6.isValid()) || (!hdr.inner_ipv4.isValid()));
+        standard_metadata.egress_spec = 9w511;
+    }
+}
+
+
+
+control MyEgress(inout headers hdr,
+                 inout metadata meta,
+                 inout standard_metadata_t standard_metadata) {
+    apply {  }
+}
+
+
+
+control MyComputeChecksum(inout headers hdr, inout metadata meta) {
+     apply {
+	update_checksum(
+	    hdr.ipv4.isValid(),
+            { hdr.ipv4.version,
+	      hdr.ipv4.ihl,
+              hdr.ipv4.diffserv,
+              hdr.ipv4.totalLen,
+              hdr.ipv4.identification,
+              hdr.ipv4.flags,
+              hdr.ipv4.fragOffset,
+              hdr.ipv4.ttl,
+              hdr.ipv4.protocol,
+              hdr.ipv4.srcAddr,
+              hdr.ipv4.dstAddr },
+            hdr.ipv4.hdrChecksum,
+            HashAlgorithm.csum16);
+    }
+}
+
+
+
+
+control MyDeparser(packet_out packet, in headers hdr) {
+    apply {
+
+    }
+}
+
+
+
+V1Switch(
+MyParser(),
+MyVerifyChecksum(),
+MyIngress(),
+MyEgress(),
+MyComputeChecksum(),
+MyDeparser()
+) main;