Carmelo Cascone

Carmelo Cascone

Auto-generated profile, based on publicly available information

Carmelo Cascone

Dipartimento di Elettronica, Informazione e Bioingegneria, Politecnico di Milano, Italy

Research Focus & Metrics

Academic Career Length

14Years (2013-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
8 April 2014 in ACM SIGCOMM Computer Communication Review
Verified
Journal Article
Open access
GBGiuseppe Bianchi
Giuseppe Bianchi
MBMarco Bonola
Marco Bonola
ACAntonio Capone
Antonio Capone
CCCarmelo Cascone
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.

1 March 2015
Verified
Conference Paper
Closed access
ACAntonio Capone
Antonio Capone
CCCarmelo Cascone
Carmelo Cascone
ANAlessandro Q. T. Nguyen
Alessandro Q. T. Nguyen
BSBrunilde Sanso
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.

1 September 2015
Verified
Conference Paper
Closed access
CCCarmelo Cascone
Carmelo Cascone
LPLuca Pollini
Luca Pollini
DSDavide Sanvito
Davide Sanvito
ACAntonio Capone
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.

1 June 2016
Verified
Conference Paper
Closed access
CCCarmelo Cascone
Carmelo Cascone
LPLuca Pollini
Luca Pollini
DSDavide Sanvito
Davide Sanvito
ACAntonio Capone
Antonio Capone
BSBrunilde Sanso
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.

1 July 2015
Verified
Conference Paper
Closed access
SPSalvatore Pontarelli
Salvatore Pontarelli
MBMarco Bonola
Marco Bonola
GBGiuseppe Bianchi
Giuseppe Bianchi
ACAntonio Capone
Antonio Capone
CCCarmelo Cascone
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.

1 October 2013
Verified
Conference Paper
Closed access
ACAntonio Capone
Antonio Capone
CCCarmelo Cascone
Carmelo Cascone
LGLuca G. Gianoli
Luca G. Gianoli
BSBrunilde Sanso
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.