Javier París

Increasing functional coverage by inductive testing: a case study

This paper addresses the challenge of generating test sets that achieve functional coverage, in the absence of a complete specification. The inductive testing technique works by probing the system behaviour with tests, and using the test results to construct an internal model of software behaviour, which is then used to generate further tests. The idea in itself is not new, but prior attempts to implement this idea have been hampered by expense and scalability, and inflexibility with respect to testing strategies. In the past, inductive testing techniques have tended to focus on the inferred models, as opposed to the suitability of the test sets that were generated in the process. This paper presents a flexible implementation of the inductive testing technique, and demonstrates its application with case-study that applies it to the Linux TCP stack implementation. The evaluation shows that the generated test sets achieve a much better coverage of the system than would be achieved by similar non-inductive techniques.

Automatic testing of TCP/IP implementations using QuickCheck

We describe how to use model based testing for testing a network stack. We present a framework that together with the property based testing tool QuickCheck can be used to test the TCP layer of the Internet protocol stack. TCP is a rather difficult protocol to test, since it hides a lot of operations for the user that communicates to the stack via a socket interface. Internally, a lot happens and by only controlling the interface, full testing is not possible. This is typical for more complex protocols and we therefore claim that the presented method can easily be extended to other cases. We present an automatic test case generator for TCP using Quickcheck. This tester generates packet flows to test specific features of a TCP stack. It then controls the stack under test to run the test by using the interface provided by it (for example, the socket interface), and by sending replies to the packets created by the stack under test. We validated the test framework on the standard Linux TCP/IP implementation.

A high performance Erlang Tcp/Ip stack

Functional languages are not often associated with the development of network stacks, mainly due to the lower performance and lack of support for system programming than more conventional languages such as C. However, there are functional languages that offer features which make it easier to develop network protocols than using a more conventional approach based on an imperative language. Erlang, for instance, offers support for distribution, concurrency and soft real time built-in into the language. All those features are desirable to ease the development of network protocol implementations. It is also possible to implement a reasonably efficient network stack in this language, provided some precautions are taken in the design. By using Erlang distribution it is possible to support fault tolerant distributed Tcp connections that take advantage of the distributed nature of the applications implemented in Erlang to provide low cost synchronization, with just some support from the application itself.

Developing a functional Tcp/Ip stack oriented towards Tcp connection replication

Functional languages are not often associated with the development of network stacks, mainly due to the lower performance and lack of support for system programming than more conventional languages such as C. However, there are functional languages that offer features which make it easier to develop network protocols than using a more conventional approach based on an imperative language. Erlang, for instance, offers support for distribution, concurrency and soft real time built-in into the language. All those features are desirable to ease the development of network protocol implementations. It is also possible to implement a reasonably efficient network stack in this language, provided some precautions are taken in the design. By using Erlang distribution it is possible to support fault tolerant distributed TCP connections that take advantage of the distributed nature of the applications implemented in Erlang to provide low cost synchronization, with just some support from the application itself.

A Distributed System for Massive Generation of Synthetic Video Using GPUs

Audio-visual interactive content is very common nowadays. It has many applications in very different fields, from videogames to visualization of scientific data. However, there are environments such as digital television in which the delivery of interactive content is of interest, but are limited by the shortcomings of the players. For example, in cable TV environments users access content through a set-top box, which is usually very limited in computing power due to cost, power consumption and the need to keep a moderate size. Furthermore, set-top boxes do not usually have specific hardware for graphics processing (GPU, Graphics Processing Unit) desirable for high quality interactive content, but rather are optimized for real time decoding of video in hardware (usually Mpeg-2, in very recent ones h.264). In this work we describe a distributed system for the creation of synthetic content and its encoding to digital video to send it to the clients. The most important features to provide are scalability and fault tolerance, in order to support a large number of concurrent users with an uninterrupted service.

A distributed filesystem for spare storage

Having access to large quantities of storage space has always been a problem. Traditionally, large storage capacity has been expensive, using dedicated storage systems (NAS), or more complex networked storage (SAN). In many cases these solutions are overkill both in price and in features. Many small offices and research labs with limited budget have computers with unused disk space that could be used as shared storage. A distributed filesystem can take advantage of the storage space of several computers to provide a larger storage. For a small office or lab this filesystem would have to provide easy integration into the infrastructure and reasonable scalability. In this work we propose a filesystem that provides access to a large storage using the unused space in a network of workstations.

The Foldl Operator as a Coequalizer Using Coq

In the present work a Coq based approach is taken to characterize the foldl using a functorial structure from which an inductive type is determined. With μF being an initial F---algebra and (B,?) another F---algebra, two F---algebras with support B×μF are constructed and then coequalized. This coequalization morphism allows the definition of foldl structurally. After examining some significant examples we propose the following methodology to define a foldl operator. Let F be a polynomial endofunctor and (μF,inF) its initial algebra. We define two F---algebras with support B×μF, and h1,h2:F(B×μF) ?B ×μF constructed such that in one of them the argument of the initial type is syntactically (structurally) lower than that in the other. Then,

CheapTB: a low cost of operation distributed filesystem

{\mathit{foldl}}:B\times\mu_F \rightarrow B

Database access and patterns in Erlang/OTP

can be defined as a specific morphism that coequalizes them

A Survey of Efficient Resource Discovery Techniques on DHTs

(h_1;{\mathit{foldl}}=h_2;{\mathit{foldl}}).