1,720,984 research outputs found
A Probabilistic Counting Framework for Distributed Measurements
Get PDFThe technological maturity attained by general purpose processors and network interface cards makes today's commodity PCs viable and high performing alternatives to specialized hardware for deploying network devices, such as switches, routers, and generic middleboxes. In addition, the flexibility of the software solution seems to be perfectly in line with the emerging trend towards the data-plane programming abstractions brought by recent proposals such as Openflow and the P4 language. However, if programming abstractions provide the way elementary instructions (primitives) are combined together, the development of such processing primitives is left to the network programmer. Although the type of such functions is strongly domain specific, we can safely assume that the counting primitive is easily required in a great deal of practical contexts. This paper presents a counting framework based on probabilistic sketches and LogLog counters for estimating the cardinality of large multi-sets of data. The proposed data structure is designed to be fast and compact for ready use in the on-line chain of processing of network devices running at multi-gigabit speeds. The complete implementation is provided within the probabilistic data structures (pds) library which has been designed, developed, experimentally assessed, and released as open-source for free download. Although the paper specifically presents two possible use-cases, the pds library can be used in rather general scenarios, even outside the networking domain
Network Traffic Processing with PFQ
Get PDFThis paper presents Packet Family Queue (PFQ), a high-performance framework for packet processing designed to flexibly handle network applications parallelism and making traffic processing safe and easy. PFQ is an open-source module for the Linux kernel that combines software-accelerated packet I/O to in-kernel early stage packet processing and fine-grained distribution to network applications and physical devices. PFQ does not require any modification to network device drivers and exposes programming interfaces to multi-threaded applications natively designed to run on top of it, as well as to legacy monitoring tools using the pcap library. The results show that the flexibility and the backward compatibility provided by PFQ do not impact its processing performance that, in fact, reaches line rate figures in the cases of pure speed tests and real practical monitoring use cases on 10+ Gb/s links
Adaptive Resource Allocation Scheme to Provide Low-Cost Multimedia Services via Satellite
No full textBRUTE: A High Performance and Extensibile Traffic Generator
No full textEvaluating the performance of high speed networks is a critical task due to the lack of reliable tools to generate traffic workloads at high rates and to the inaccessibility of network equipments. To address the problem of reliable device testing, we developed an extensible traffic generator, called BRUTE (Browny and RobUst Traffic Engine), running on top of Linux operating system. BRUTE takes advantage of the Linux kernel potential in order to accurately generate traffic flows up to very high bitrates. This software is an extensible framework that provides a number of optimized functions that easily allow the implementation of ad hoc modules for customized traffic patterns generation. A number of library modules implementing common traffic profiles (like CBR, Poisson process and Poissonian Arrival of Burst process) are already implemented and integrated into the package. Performance of BRUTE has been compared to the one of several widespread traffic generators over Fast-Ethernet and Gigabit-Ethernet networks. The results of our tests show the superior performance of BRUTE in terms of both the achieved throughput and the level of bitrate precision, under all possible values of the frame length
Randomized packet filtering through specialized partitioning of rulesets
Get PDFA key issue in high speed traffic processing is to immediately detect potentially interesting packets. At very high speed, this operation is particularly crucial as filtering packets close to the wire relieves real applications from handling large volumes of (uninteresting) data. This paper proposes a fast and randomized approach to packet filtering based on partitioning rule databases for their storage in fast and compact Bloom filters that can be placed in fast cache memory. Database partitioning is obtained by a specially tailored clustering algorithm and the results show that even large rulesets can be divided into a limited number of partitions and accommodated in reasonably small Bloom filters. © 1997-2012 IEEE
On Memory Allocation for High-Speed Packet Analysis Applications
No full textThe evolution of commodity hardware makes it a very attractive platform to develop high–performance networking applications that are affordable to deploy. All but the most trivial applications must copy packets into user–space for further analysis. Therefore, the allocation of memory for these copies becomes a performance–critical operation. In this work, we present a multi–layer slice memory allocator specifically designed to take advantage of spatial and temporal locality in dealing with high–speed packet processing applications. Experimental results show that the proposed approach clearly outperforms existing memory allocators in common networking use–cases
A pipeline functional language for stateful packet processing
No full textThe evolution of commodity PCs towards multi-core processing platforms equipped with high-speed network interfaces makes them reasonable and cost effective targets for the implementation of generic network functions. In addition, the availability of software accelerated I/O frameworks provides a convenient ground for running a broad variety of applications, from simple software switches to more complex network systems, with near hardware-class performance and the flexibility of a software approach. Most network functions can be implemented by composing a set of elementary operations into processing pipelines to be run on top of multiple processing cores. In this framework, maintaining the flow consistency is crucial to enable stateful operations in the processing pipelines. This paper presents Enif-Lang, a functional language for programming network pipelines specifically targeted at multi-core scenarios. In addition to a large set of functions for generic packet manipulation, filtering, steering and state management, the framework is built upon an abstract model that provides state aware packet splitting to prevent inter-state sharing and enable consistent stateful parallel processing on-top-of multi-core architectures
Enabling packet fan-out in the libpcap library for parallel traffic processing
No full textThe large availability of multi-gigabit network cards for commodity PCs requires network applications to potentially cope with high volumes of traffic. However, computation intensive operations may not catch up with high traffic rates and need to be run in parallel over multiple processing cores. As of today, the vast majority of network applications are still based on the use of the pcap library interface which, unfortunately, does not provide a native multi-core support, even though the underlying capture technologies do. This paper introduces a novel version of the pcap library for the Linux operating-system that allows application level parallelism. The new library natively supports fanout operations for both multi-threaded and multi-process applications, by means of extended API as well as by a declarative grammar configuration suitable for legacy applications. In addition, the library can transparently run on top of the standard Linux socket and other accelerated capture engines. Performance evaluation has been carried out on a multi-core architecture in pure capture tests and in more realistic use cases involving monitoring applications such as Tstat and Bro, with standard Linux socket and the PFQ accelerated engine
Enif-lang: A specialized language for programming network functions on commodity hardware
Get PDFThe maturity level reached by today’s commodity platforms makes even low-cost PCs viable alternatives to dedicated hardware to implement real network functions without sacrificing performance. Indeed, the availability of multi-core processing packages and multi-queue network interfaces that can be managed by accelerated I/O frameworks, provides off-the-shelf servers with the necessary power capability for running a broad variety of network applications with near hardware-class performance. At the same time, the introduction of the Software Defined Networks (SDN) and the Network Functions Virtualization (NFV) paradigms call for new programming abstractions and tools to allow this new class of network devices to be flexibly configured and functionally repurposed from the network control plane. The paper presents the ongoing work towards Enif-Lang (Enhanced Network processIng Functional Language), a functional language for programming network functions over generic middleboxes running the Linux operating system. The language addresses concurrent programming by design and is targeted at developing simple stand-alone applications as well as pre-processing stages of packet elaborations. Enif-Lang is implemented as a Domain Specific Language embedded in the Haskell language and inherits the main principles of its ancestor, including the strong typedness and the concept of function compositions. Complex network functions are implemented by composing a set of elementary operations (primitives) by means of a compact yet expressive language grammar. Throughout the paper, the description of the design principles and features of Enif-Lang are accompanied by examples and use cases. In addition, a preliminary performance assessment is carried out to prove the effectiveness of the language for developing practical applications with the performance level required by 5G systems and the Tactile Internet
A purely functional approach to packet processing
No full textToday's rapidly evolving network ecosystem, characterized by increasing traffic volumes, service heterogeneity and mutating cyber-threats, calls for new approaches to packet pro-cessing to address key issues such as scalability, flexibility, programmability and fast deployment. To this aim, this paper explores a new direction to packet processing by pushing forward functional programming principles in the definition of a "software defined networking" paradigm. This result is achieved by introducing PFQ-Lang, an extensible functional language which can be used to process, analyze and forward packets captured on modern multiqueue NICs (for example, it allows to quickly develop the early stage of monitoring applications). An implementation of PFQ-Lang, embedded into high level programming languages as an eDSL (embedded Domain Specific Language) is also presented. The proposed approach allows an easy development by leveraging the intuitive functional composition and, at the same time, allows to exploit multi-queue NICs and multi-core architectures to process high-speed network traffic. Experimental results are provided to prove that the presented implementation reaches line rate performance on a 10Gb line card. To demonstrate the effectiveness and expressiveness of PFQ-Lang, the paper also presents a few use-cases ranging from forwarding, firewalling and monitoring of real traffic
- …
