11 research outputs found
Static slicing of explicitly synchronized languages
Static analysis of concurrent languages is a complex task due to the non-deterministic execution of processes. If the concurrent language being studied allows process synchronization, then the analyses are even more complex (and thus expensive), e.g., due to the phenomenon of deadlock. In this work we introduce a static analysis technique based on program slicing for concurrent and explicitly synchronized languages in general, and CSP in particular. Concretely, given a particular point in a specification, our technique allows us to know what parts of the specification must necessarily be executed before this point, and what parts of the specification could be executed before it. Our technique is based on a new data structure that extends the Synchronized Control Flow Graph (SCFG). We show that this new data structure improves the SCFG by taking into account the context in which processes are called and, thus, it makes the slicing process more precise. The technique has been implemented and tested with real specifications, producing good results. After formally defining our technique, we describe our tool, its architecture, its main applications and the results obtained from several experiments conducted in order to measure the performance of the tool. © 2012 Elsevier Inc. All rights reserved.This work has been partially supported by the Spanish Ministerio de Economia y Competitividad (Secretaria de Estado de Investigacion, Desarrollo e Innovacion) under grant TIN2008-06622-C03-02 and by the Generalitat Valenciana under grant PROMETEO/2011/052. Salvador Tamarit was partially supported by the Spanish MICINN under FPI grant BES-2009-015019.Leuschel ., M.; Llorens Agost, ML.; Oliver Villarroya, J.; Silva Galiana, JF.; Tamarit Muñoz, S. (2012). Static slicing of explicitly synchronized languages. Information and Computation. 214:10-46. https://doi.org/10.1016/j.ic.2012.02.005S104621
srcSlice: very efficient and scalable forward static slicing
A highly efficient lightweight forward static slicing approach is presented and evaluated. The approach does not compute the program/system dependence graph but instead dependence and control information is com-puted as needed while computing the slice on a variable. The result is a list of line numbers, dependent vari-ables, aliases, and function calls that are part of the slice for all variables (both local and global) for the entire system. The method is implemented as a tool, called srcSlice, on top of srcML, an XML representation of source code. The approach is highly scalable and can generate the slices for all variables of the Linux kernel in approximately 20min on a typical desktop. Benchmark results are compared with the CodeSurfer slicing tool from GrammaTech Inc., and the approach compares well with regard to accuracy of slices. Copyright
Analysis Techniques for Concurrent Programming Languages
Los lenguajes concurrentes est an cada d a m as presentes en nuestra sociedad,
tanto en las nuevas tecnolog as como en los sistemas utilizados de manera cotidiana. M as a un, dada la actual distribuci on de los sistemas y su arquitectura interna,
cabe esperar que este hecho siga siendo una realidad en los pr oximos a~nos. En
este contexto, el desarrollo de herramientas de apoyo al desarrollo de programas
concurrentes se vuelve esencial. Adem as, el comportamiento de los sistemas concurrentes es especialmente dif cil de analizar, por lo que cualquier herramienta que
ayude en esta tarea, a un cuando sea limitada, ser a de gran utilidad. Por ejemplo, podemos encontrar herramientas para la depuraci on, an alisis, comprobaci on,
optimizaci on, o simpli caci on de programas. Muchas de ellas son ampliamente
utilizadas por los programadores hoy en d a.
El prop osito de esta tesis es introducir, a trav es de diferentes lenguajes de
programaci on concurrentes, t ecnicas de an alisis que puedan ayudar a mejorar la
experiencia del desarrollo y publicaci on de software para modelos concurrentes.
En esta tesis se introducen tanto an alisis est aticos (aproximando todas las posibles ejecuciones) como din amicos (considerando una ejecuci on en concreto). Los
trabajos aqu propuestos di eren lo su ciente entre s para constituir ideas totalmente independientes, pero manteniendo un nexo com un: el hecho de ser un
an alisis para un lenguaje concurrente. Todos los an alisis presentados han sido
de nidos formalmente y se ha probado su correcci on, asegurando que los resultados obtenidos tendr an el grado de abilidad necesario en sistemas que lo requieran,
como por ejemplo, en sistemas cr ticos. Adem as, se incluye la descripci on de las
herramientas software que implementan las diferentes ideas propuestas. Esto le da
al trabajo una utilidad m as all a del marco te orico, permitiendo poner en pr actica
y probar con ejemplos reales los diferentes an alisis.
Todas las ideas aqu presentadas constituyen, por s mismas, propuestas aplicables en multitud de contextos y problemas actuales. Adem as, individualmente sirven de punto de partida para otros an alisis derivados, as como para la adaptaci on
a otros lenguajes de la misma familia. Esto le da un valor a~nadido a este trabajo,
como bien atestiguan algunos trabajos posteriores que ya se est an bene ciando de
los resultados obtenidos en esta tesis.Concurrent languages are increasingly present in our society, both in new
technologies and in the systems used on a daily basis. Moreover, given the
current systems distribution and their internal architecture, one can expect
that this remains so in the coming years. In this context, the development of
tools to support the implementation of concurrent programs becomes essential.
Futhermore, the behavior of concurrent systems is particularly difficult
to analyse, so that any tool that helps in this task, even if in a limited way,
will be very useful. For example, one can find tools for debugging, analysis,
testing, optimisation, or simplification of programs, which are widely used
by programmers nowadays.
The purpose of this thesis is to introduce, through various concurrent programming
languages, some analysis techniques that can help to improve the
experience of the software development and release for concurrent models.
This thesis introduces both static (approximating all possible executions) and
dynamic (considering a specific execution) analysis. The topics considered
here differ enough from each other to be fully independent. Nevertheless,
they have a common link: they can be used to analyse properties of a concurrent
programming language. All the analyses presented here have been
formally defined and their correctness have been proved, ensuring that the
results will have the reliability degree which is needed for some systems (for
instance, for critical systems). It also includes a description of the software
tools that implement the different ideas proposed. This gives the work a usefulness
well beyond the theoretical aspect, allowing us to put it in practice
and to test the different analyses with real-world examples All the ideas here presented are, by themselves, approaches that can be applied
in many current contexts and problems. Moreover, individually they
serve as a starting point for other derived analysis, as well as for the adaptation
to other languages of the same family. This gives an added value to
this work, a fact confirmed by some later works that are already benefiting
from the results obtained in this thesis.Tamarit Muñoz, S. (2013). Analysis Techniques for Concurrent Programming Languages [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/31651TESI
Automatic generation of test scenarios from the models of systems specification
Orientador: Eliane MartinsDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de ComputaçãoResumo: As crescentes exigências em relação à melhoria de qualidade e a redução de custos e prazos têm tornado comum à busca por soluções mais eficientes para desenvolvimento e testes de sistemas. Com relação aos testes, uma recomendação é a de começá-los mais cedo, e, de preferência, automatizar o que for possível para evitar enganos cometidos pelos testadores. Assim, uma área de pesquisa que está em evidência atualmente é a de testes baseados em modelos (MBT), onde muitos estudos têm sido realizados visando o desenvolvimento de soluções para automação de testes a partir de modelos criados durante o ciclo de desenvolvimento. Nesta dissertação é proposto um método para geração automática de cenários de teste a partir de modelos da especificação de sistemas, baseando-se em um trabalho prévio para geração de testes de componentes de software. Os modelos utilizados para geração dos testes são os Diagramas de Atividades UML, criados a partir da descrição dos casos de uso, para Testes de Sistemas. A partir deles são gerados cenários de teste que descrevem as interações do sistema, tais como, as ações dos atores e as situações esperadas, incluindo também os cenários de exceção. A aplicação deste método na prática foi feita com êxito por uma equipe de testadores em sistemas reais. De forma geral, os modelos especificados para derivação dos testes têm facilitado o entendimento do sistema pelos testadores envolvidos e as informações presentes nos cenários de teste têm apoiado a realização dos testes.Abstract: The increasing requirements for quality improvement, reduction of costs and deadlines have promoted the search for more efficient solutions for systems development and testing. In the case of the tests, the recommendation is to start them earlier and, preferably, automatize what is possible to prevent the testers mistakes. Thus, a research area that is in evidence currently is the Model-Based Testing (MBT), in which many studies have been carried out with the aim of development solutions for test automation from the models created during the software development cycle. In this dissertation is proposed a method for automatic generation of test scenarios from the models of systems specification, it is based on a previous work for tests generation of software components. The models used for tests generation are the UML Activities Diagrams, generated from the description of the use cases for System Testing. From them, test scenarios are generated that describe the interactions of the system, such as, the actors actions and the expected situations, including also the exception scenarios. The application of this method in practice was successfully made by a team of testers in real systems. In general, the models specified for tests derivation have facilitated the agreement of the system by the involved testers and, the generated test scenarios contain information that have supported the test execution.MestradoMestre em Ciência da Computaçã
Computation of interprocedural control dependence
Program-dependence information is useful for a variety of applications, such as software testing and maintenance tasks, and code optimization. Properly defined, control and data dependences can be used to identify semantic dependences. To function effectively on whole programs, tools that utilize dependence information require information about interprocedural dependences: dependences that are identified by analyzing the interactions among procedures. Many techniques for computing interprocedural data dependences exist; however, virtually no attention has been paid to interprocedural control dependence. Analysis techniques that fail to account for interprocedural control dependences can suffer unnecessary imprecision and loss of safety. This article presents a definition of interprocedural control dependence that supports the relationship of control and data dependence to semantic dependence. The article presents two approaches for computing interprocedural control dependences, and empirical results pertaining to the use of those approaches
Computation of interprocedural control dependence
Program-dependence information is useful for a variety of applications, such as software testing and maintenance tasks and code optimization. Properly defined, control and data dependences can be used to identify semantic dependences. To function effectively on whole programs, tools that utilize dependence information require information about interprocedural dependences: dependences that are identified by analyzing the interactions among procedures. Many techniques for computing interprocedural data dependences exist; however, virtually no attention has been paid to interprocedural control dependence. Analysis techniques that fail to account for interprocedural control dependences can suffer unnecessary imprecision and loss of safety. This paper presents a definition of interprocedural control dependence that supports the relationship of control and data dependence to semantic dependence. The paper presents two approaches for computing interprocedural control dependences, and empirical results pertaining to the use of those approaches
Efficient Computation of Interprocedural Control Dependence
Control dependence information is useful for a wide range of software maintenance and testing tasks. For example, program slicers use it to determine statements and predicates that might affect the value of a particular variable at a particular program location. In the intraprocedural context an optimal algorithm is known for computing control dependence which unfortunately relies critically on the underlying intraprocedural postdominance relation being tree-structured. Hence, this algorithm is not directly applicable to the interprocedural case where the transitive reduction of the postdominance relation can be a directed acyclic graph (DAG), with nodes having multiple immediate dominators. In this paper we present two efficient, conceptually simple algorithms for computing the interprocedural postdominance relation that can be used to compute interprocedural control dependence. For an interprocedural control flow graph , our reachability based algorithm takes time and space . Unlike other algorithms, it does not perform confluence operations on whole bit-vectors and can be tuned to concentrate on the interprocedural rather than intraprocedural relations in a program thus allowing it to scale better to larger programs