CCCarmelo Cascone

Carmelo Cascone

*This is an algorithmically generated author record based on publicly available information.

Current Organizations / Institutes

The organizations/institutes from the scholar's latest article


Carmelo Cascone has a total of 18 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • Open Access

    Hydra: Effective Runtime Network Verification

    by Sundararajan Renganathan, Benny Rubin, Hyojoon Kim, Pier Luigi Ventre, Carmelo Cascone, Daniele Moro, Charles Chan, Nick McKeown, Nate Foster

    It is notoriously difficult to verify that a network is behaving as intended, especially at scale. This paper presents Hydra, a system that uses ideas from runtime verification to check that every packet is correctly processed with respect to a specification in real time. We propose a domain-specific language for writing properties, called Indus, and we develop a compiler that turns properties thus specified into executable P4 code that runs alongside the forwarding code at line rate. To evaluate our approach, we used Indus to model a range of properties, showing that it is expressive enough to capture examples studied in prior work. We also deployed Hydra checkers for validating paths in source routing and for enforcing slice isolation in Aether, an open-source cellular platform. We confirmed a subtle bug in Aether's 5G mobile core that would have been hard to detect using static techniques. We also evaluated the overheads of Hydra on hardware, finding that it does not significantly increase latency and often does not require additional pipeline stages.


  • SPIDER: Fault resilient SDN pipeline with recovery delay guarantees

    by Carmelo Cascone, Luca Pollini, Davide Sanvito, Antonio Capone, Brunilde Sanso

    When dealing with node or link failures in Software Defined Networking (SDN), the network capability to establish an alternative path depends on controller reachability and on the round trip times (RTTs) between controller and involved switches. Moreover, current SDN data plane abstractions for failure detection (e.g. OpenFlow “Fast-failover”) do not allow programmers to tweak switches' detection mechanism, thus leaving SDN operators still relying on proprietary management interfaces (when available) to achieve guaranteed detection and recovery delays. We propose SPIDER, an OpenFlow-like pipeline design that provides i) a detection mechanism based on switches' periodic link probing and ii) fast reroute of traffic flows even in case of distant failures, regardless of controller availability. SPIDER can be implemented using stateful data plane abstractions such as OpenState or Open vSwitch, and it offers guaranteed short (i.e. ms) failure detection and recovery delays, with a configurable trade off between overhead and failover responsiveness. We present here the SPIDER pipeline design, behavioral model, and analysis on flow tables' memory impact. We also implemented and experimentally validated SPIDER using OpenState (an OpenFlow 1.3 extension for stateful packet processing), showing numerical results on its performance in terms of recovery latency and packet losses.


  • Traffic Management Applications for Stateful SDN Data Plane

    by Carmelo Cascone, Luca Pollini, Davide Sanvito, Antonio Capone

    The successful Open Flow approach to Software Defined Networking (SDN) allows network programmability through a central controller able to orchestrate a set of dumb switches. However, the simple match/action abstraction of Open Flow switches constrains the evolution of the forwarding rules to be fully managed by the controller. This can be particularly limiting for a number of applications that are affected by the delay of the slow control path, like traffic management applications. Some recent proposals are pushing toward an evolution of the Open Flow abstraction to enable the evolution of forwarding policies directly in the data plane based on state machines and local events. In this paper, we present two traffic management applications that exploit a stateful data plane and their prototype implementation based on Open State, an Open Flow evolution that we recently proposed.


  • Stateful OpenFlow: Hardware proof of concept

    by Salvatore Pontarelli, Marco Bonola, Giuseppe Bianchi, Antonio Capone, Carmelo Cascone

    This paper presents a hardware implementation of Openstate, an extension of OpenFlow that allows performing stateful control functionalities directly inside the switch, without requiring the intervention of an external controller. The paper shows how, with a minimal reworking of the OpenFlow's basic architecture, and reusing the same building blocks, it is possible to greatly extend the intelligence of an OpenFlow switch allowing the offload of many control task directly in the switch. An FPGA based implementation of an Openstate prototype is here presented, the different architectural design choices are discussed, and the performance and limitations of the developed prototype are examinated. Finally, the paper proposes a discussion on the performance achievable by using an ASIC implementation of the OpenState switch1.


  • Detour planning for fast and reliable failure recovery in SDN with OpenState

    by Antonio Capone, Carmelo Cascone, Alessandro Q. T. Nguyen, Brunilde Sanso

    A reliable and scalable mechanism to provide protection against a link or node failure has additional requirements in the context of SDN and OpenFlow. Not only it has to minimize the load on the controller, but it must be able to react even when the controller is unreachable. In this paper we present a protection scheme based on precomputed backup paths and inspired by MPLS “crankback” routing, that guarantees instantaneous recovery times and aims at zero packet-loss after failure detection, regardless of controller reachability, even when OpenFlow's “fast-failover” feature cannot be used. The proposed mechanism is based on OpenState, an OpenFlow extension that allows a programmer to specify how forwarding rules should autonomously adapt in a stateful fashion, reducing the need to rely on remote controllers. We present the scheme as well as two different formulations for the computation of backup paths.


  • Top Cited Papers
    Open Access

    OpenState

    by Giuseppe Bianchi, Marco Bonola, Antonio Capone, Carmelo Cascone

    Software Defined Networking envisions smart centralized controllers governing the forwarding behavior of dumb low-cost switches. But are "dumb" switches an actual strategic choice, or (at least to some extent) are they a consequence of the lack of viable alternatives to OpenFlow as programmatic data plane forwarding interface? Indeed, some level of (programmable) control logic in the switches might be beneficial to offload logically centralized controllers (de facto complex distributed systems) from decisions just based on local states (versus network-wide knowledge), which could be handled at wire speed inside the device itself. Also, it would reduce the amount of flow processing tasks currently delegated to specialized middleboxes. The underlying challenge is: can we devise a stateful data plane programming abstraction (versus the stateless OpenFlow match/action table) which still entails high performance and remains consistent with the vendors' preference for closed platforms? We posit that a promising answer revolves around the usage of extended finite state machines, as an extension (super-set) of the OpenFlow match/action abstraction. We concretely turn our proposed abstraction into an actual table-based API, and, perhaps surprisingly, we show how it can be supported by (mostly) reusing core primitives already implemented in OpenFlow devices.


  • OSPF optimization via dynamic network management for green IP networks

    by Antonio Capone, Carmelo Cascone, Luca G. Gianoli, Brunilde Sanso

    In this paper we present a novel experimental platform for network management able to dynamically optimize the energy consumption of backbone IP networks operating with OSPF. The idea is to efficiently adjust link weights to put to sleep idle devices. The framework relies on multiple precomputed sets of link weights that are applied to the considered network domain according to real time measurements on the link utilization. The management module exploits the Simple Network Management Protocol (SNMP) to collect the load measurements and modify the link weights. The pre-computed link weights are calculated by running a state-of-the-art algorithm for off-line energy-aware traffic engineering based on predicted traffic matrices. The modules of the platforms have been implemented for Linux based environments and tested using emulated networks of virtual machines. Experimental results showed a significant reduction in terms of network resources required to route traffic demands, demonstrating how, in average, 20% of nodes and 40% of links, can be put to sleep without compromising network performance and stability.