The Experts below are selected from a list of 30360 Experts worldwide ranked by ideXlab platform
Andrei Sabelfeld - One of the best experts on this subject based on the ideXlab platform.
-
boosting the permissiveness of Dynamic information flow tracking by testing
European Symposium on Research in Computer Security, 2012Co-Authors: Arnar Birgisson, Daniel Hedin, Andrei SabelfeldAbstract:Tracking information flow in Dynamic Languages remains an open challenge. It might seem natural to address the challenge by runtime monitoring. However, there are well-known fundamental limits of Dynamic flow-sensitive tracking of information flow, where paths not taken in a given execution contribute to information leaks. This paper shows how to overcome the permissiveness limit for Dynamic analysis by a novel use of testing. We start with a program supervised by an information-flow monitor. The security of the execution is guaranteed by the monitor. Testing boosts the permissiveness of the monitor by discovering paths where the monitor raises security exceptions. Upon discovering a security error, the program is modified by injecting an annotation that prevents the same security exception on the next run of the program. The elegance of the approach is that it is sound no matter how much coverage is provided by the testing. Further, we show that when the mechanism has discovered the necessary annotations, then we have an accuracy guarantee: the results of monitoring a program are at least as accurate as flow-sensitive static analysis. We illustrate our approach for a simple imperative language with records and exceptions. Our experiments with the QuickCheck tool indicate that random testing accurately discovers annotations for a collection of scenarios with rich information flows.
-
information flow security for a core of javascript
IEEE Computer Security Foundations Symposium, 2012Co-Authors: Daniel Hedin, Andrei SabelfeldAbstract:Tracking information flow in Dynamic Languages remains an important and intricate problem. This paper makes substantial headway toward understanding the main challenges and resolving them. We identify language constructs that constitute a core of Java Script: objects, higher-order functions, exceptions, and Dynamic code evaluation. The core is powerful enough to naturally encode native constructs as arrays, as well as functionalities of Java Script's API from the document object model (DOM) related to document tree manipulation and event processing. As the main contribution, we develop a Dynamic type system that guarantees information-flow security for this language.
-
tight enforcement of information release policies for Dynamic Languages
IEEE Computer Security Foundations Symposium, 2009Co-Authors: Aslan Askarov, Andrei SabelfeldAbstract:This paper studies the problem of securing information release in Dynamic Languages. We propose (i) an intuitive framework for information-release policies expressing both what can be released by an application and where in the code this release may take place and (ii) tight and modular enforcement by hybrid mechanisms that combine monitoring with on-the-fly static analysis for a language with Dynamic code evaluation and communication primitives. The policy framework and enforcement mechanisms support both termination-sensitive and insensitive security policies.
Francisco Ortin - One of the best experts on this subject based on the ideXlab platform.
-
towards a java library to support runtime metaprogramming
International Conference on Evaluation of Novel Approaches to Software Engineering, 2017Co-Authors: Ignacio Lagartos, Jose Manuel Redondo, Francisco OrtinAbstract:Statically typed Languages such as Java offer two key advantages: robustness increase due to compile time error detection, and better runtime performance caused by the reduction of runtime type checking. However, Dynamic Languages are sometimes preferred in scenarios where runtime adaptability is a strong requirement, such as building software capable of adapting to runtime changing environments. The metaprogramming features of Dynamic Languages allow the runtime adaptation of class and object structures, modifying inheritance relationships, and the evaluation of Dynamically generated code. In this position paper, we describe the steps we are following to add to Java some of the metaprogramming services provided by most Dynamic Languages. The objective is to provide the runtime flexibility of structural intercession, Dynamic inheritance and Dynamic code evaluation, without losing the robustness of compile-time type checking. The metaprogramming services are provided as a library so, unlike other existing systems, any standard virtual machine and language implementation could be used.
-
the runtime performance of invokeDynamic an evaluation with a java library
IEEE Software, 2014Co-Authors: Francisco Ortin, Patricia Conde, Daniel Fernandezlanvin, Raul IzquierdoAbstract:The Java 7 platform includes the invokeDynamic opcode in its virtual machine, a feature that lets programmers define, and Dynamically change, the linkage of method call sites and thereby maintain platform optimizations. The authors developed a library that lets developers use this new JVM feature, present a comprehensive evaluation of its performance, and describe how to use the developed library to optimize real Java applications, including two mature Dynamic Languages.
-
efficient support of Dynamic inheritance for class and prototype based Languages
Journal of Systems and Software, 2013Co-Authors: Jose Manuel Redondo, Francisco OrtinAbstract:Highlights? We define language-neutral Dynamic inheritance for both class- and prototype-based object models. ? The semantics has been included as part of a production JIT-compiler virtual machine. ? The resulting virtual machine has been evaluated to provide significant runtime performance benefits with low memory consumption. ? Our platform supports both Dynamically and statically typed Languages, allowing a direct interoperation between them. ? Backward compatibility with existing. Net applications is maintained. Dynamically typed Languages are becoming increasingly popular for different software development scenarios where runtime adaptability is important. Therefore, existing class-based platforms such as Java and .Net have been gradually incorporating Dynamic features to support the execution of these Languages. The implementations of Dynamic Languages on these platforms commonly generate an extra layer of software over the virtual machine, which reproduces the reflective prototype-based object model provided by most Dynamic Languages. Simulating this model frequently involves a runtime performance penalty, and makes the interoperation between class- and prototype-based Languages difficult.Instead of simulating the reflective model of Dynamic Languages, our approach has been to extend the object-model of an efficient class-based virtual machine with prototype-based semantics, so that it can directly support both kinds of Languages. Consequently, we obtain the runtime performance improvement of using the virtual machine JIT compiler, while a direct interoperation between Languages compiled to our platform is also possible. In this paper, we formalize Dynamic inheritance for both class- and prototype-based Languages, and implement it as an extension of an efficient virtual machine that performs JIT compilation. We also present an extensive evaluation of the runtime performance and memory consumption of the programming language implementations that provide Dynamic inheritance, including ours.
-
Efficient virtual machine support of runtime structural reflection
Science of Computer Programming, 2009Co-Authors: Francisco Ortin, Jose Manuel Redondo, J. Baltasar García Perez-schofieldAbstract:Increasing trends towards adaptive, distributed, generative and pervasive software have made object-oriented Dynamically typed Languages become increasingly popular. These Languages offer Dynamic software evolution by means of reflection, facilitating the development of Dynamic systems. Unfortunately, this dynamism commonly imposes a runtime performance penalty. In this paper, we describe how to extend a production JIT-compiler virtual machine to support runtime object-oriented structural reflection offered by many Dynamic Languages. Our approach improves runtime performance of Dynamic Languages running on statically typed virtual machines. At the same time, existing statically typed Languages are still supported by the virtual machine. We have extended the .Net platform with runtime structural reflection adding prototype-based object-oriented semantics to the statically typed class-based model of .Net, supporting both kinds of programming Languages. The assessment of runtime performance and memory consumption has revealed that a direct support of structural reflection in a production JIT-based virtual machine designed for statically typed Languages provides a significant performance improvement for Dynamically typed Languages.
-
optimizing reflective primitives of Dynamic Languages
International Journal of Software Engineering and Knowledge Engineering, 2008Co-Authors: Jose Manuel Redondo, Francisco Ortin, Juan Manuel CuevaAbstract:Dynamic Languages are becoming widely used in software engineering due to the flexibility needs of specific software systems. Different example scenarios are the development of Dynamic aspect oriented software, Web applications, adaptable and adaptive software or application frameworks. One important lack of these Languages is compile-time error detection offered by static Languages. However, runtime performance is the most serious limitation to use them in commercial software development. Although JIT optimizing compilation is a widely used technique to speed up intermediate code execution, this has not been successfully applied to Dynamically adaptive platforms yet. We present an approach to improve the structural reflective primitives offered by Dynamic Languages. Looking for a language-neutral platform with a good JIT-based runtime performance, we have used the Microsoft shared source implementation of the CLI. Its model has been extended with semantics of prototype-based object-oriented models, much more suitable than the class-based one for reflective environments. This augmented semantics together with JIT generation of native code has produced significantly better runtime performance than the existing implementations.
Armin Rigo - One of the best experts on this subject based on the ideXlab platform.
-
virtual machine design for parallel Dynamic programming Languages
Proceedings of the ACM on Programming Languages, 2018Co-Authors: Remigius Meier, Armin Rigo, Thomas R GrossAbstract:To leverage the benefits of modern hardware, Dynamic Languages must support parallelism, and parallelism requires a virtual machine (VM) capable of parallel execution — a parallel VM. However, unrestricted concurrency and the dynamism of Dynamic Languages pose great challenges to the implementation of parallel VMs. In a Dynamic language, a program changing itself is part of the language model. To help the VM, Languages often choose memory models (MM) that weaken consistency guarantees. With lesser guarantees, local program state cannot be affected by every concurrent state change. And less interference allows a VM to make local assumptions about the program state which are not immediately violated. These local assumptions are essential for a VM’s just-in-time compiler for delivering state-of-the-art VM performance. Unfortunately, some Dynamic Languages employ MMs that give exceedingly strong consistency guarantees and thereby hinder the development of parallel VMs. Such is the case in particular for Languages that depend on a global interpreter lock, which mandates a MM with sequential consistency and instruction atomicity. In this paper, we reflect on a first implementation of the Parallel RPython execution model, which facilitates the development of parallel VMs by decoupling language semantics from the synchronization mechanism used within the VM. The implementation addresses the challenges imposed by strong MMs through strict isolation of concurrent computations. This isolation builds on transactional parallel worlds, which are implemented with a novel combination of software techniques and the capabilities of modern hardware. We evaluate a set of parallel Python programs on a parallel VM that relies on Parallel RPython’s implementation. Compared with a serial baseline VM that relies on a global interpreter lock, the parallel VM achieves speedups of up to 7.5× on 8 CPU cores. The evaluation shows that our realization of Parallel RPython meets the challenges of Dynamic Languages, and that it can serve as a solid foundation for the construction of parallel Dynamic language VMs.
-
a way forward in parallelising Dynamic Languages
Implementation Compilation Optimization of Object-Oriented Languages Programs and Systems, 2014Co-Authors: Remigius Meier, Armin RigoAbstract:Dynamic Languages became very popular in recent years. At some point, the need for concurrency arose, and many of them made the choice to use a single global interpreter lock (GIL) to synchronise the interpreter in a multithreading scenario. This choice, however, makes it impossible to actually run code in parallel.Here we want to compare different approaches to replacing the GIL with a technology that allows parallel execution. We look at fine-grained locking, shared-nothing, and transactional memory (TM) approaches. We argue that software-based TM systems are the most promising, especially since they also enable the introduction of large, parallelisable atomic blocks as a better synchronisation mechanism in the language.
-
runtime feedback in a meta tracing jit for efficient Dynamic Languages
Implementation Compilation Optimization of Object-Oriented Languages Programs and Systems, 2011Co-Authors: Carl Friedrich Bolz, Antonio Cuni, Maciej Fijalkowski, Michael Leuschel, Samuele Pedroni, Armin RigoAbstract:Meta-tracing JIT compilers can be applied to a variety of different Languages without explicitly encoding language semantics into the compiler. So far, they lacked a way to give the language implementor control over runtime feedback. This restricted their performance. In this paper we describe the mechanisms in PyPy's meta-tracing JIT that can be used to control runtime feedback in language-specific ways. These mechanisms are flexible enough to express classical VM techniques such as maps and runtime type feedback.
-
allocation removal by partial evaluation in a tracing jit
Partial Evaluation and Semantic-Based Program Manipulation, 2011Co-Authors: Carl Friedrich Bolz, Antonio Cuni, Michael Leuschel, Samuele Pedroni, Maciej Fijabkowski, Armin RigoAbstract:The performance of many Dynamic language implementations suffers from high allocation rates and runtime type checks. This makes Dynamic Languages less applicable to purely algorithmic problems, despite their growing popularity. In this paper we present a simple compiler optimization based on online partial evaluation to remove object allocations and runtime type checks in the context of a tracing JIT. We evaluate the optimization using a Python VM and find that it gives good results for all our (real-life) benchmarks.
-
tracing the meta level pypy s tracing jit compiler
Proceedings of the 4th workshop on the Implementation Compilation Optimization of Object-Oriented Languages and Programming Systems, 2009Co-Authors: Carl Friedrich Bolz, Antonio Cuni, Maciej Fijalkowski, Armin RigoAbstract:We attempt to apply the technique of Tracing JIT Compilers in the context of the PyPy project, i.e., to programs that are interpreters for some Dynamic Languages, including Python. Tracing JIT compilers can greatly speed up programs that spend most of their time in loops in which they take similar code paths. However, applying an unmodified tracing JIT to a program that is itself a bytecode interpreter results in very limited or no speedup. In this paper we show how to guide tracing JIT compilers to greatly improve the speed of bytecode interpreters. One crucial point is to unroll the bytecode dispatch loop, based on two kinds of hints provided by the implementer of the bytecode interpreter. We evaluate our technique by applying it to two PyPy interpreters: one is a small example, and the other one is the full Python interpreter.
Jose Manuel Redondo - One of the best experts on this subject based on the ideXlab platform.
-
towards a java library to support runtime metaprogramming
International Conference on Evaluation of Novel Approaches to Software Engineering, 2017Co-Authors: Ignacio Lagartos, Jose Manuel Redondo, Francisco OrtinAbstract:Statically typed Languages such as Java offer two key advantages: robustness increase due to compile time error detection, and better runtime performance caused by the reduction of runtime type checking. However, Dynamic Languages are sometimes preferred in scenarios where runtime adaptability is a strong requirement, such as building software capable of adapting to runtime changing environments. The metaprogramming features of Dynamic Languages allow the runtime adaptation of class and object structures, modifying inheritance relationships, and the evaluation of Dynamically generated code. In this position paper, we describe the steps we are following to add to Java some of the metaprogramming services provided by most Dynamic Languages. The objective is to provide the runtime flexibility of structural intercession, Dynamic inheritance and Dynamic code evaluation, without losing the robustness of compile-time type checking. The metaprogramming services are provided as a library so, unlike other existing systems, any standard virtual machine and language implementation could be used.
-
efficient support of Dynamic inheritance for class and prototype based Languages
Journal of Systems and Software, 2013Co-Authors: Jose Manuel Redondo, Francisco OrtinAbstract:Highlights? We define language-neutral Dynamic inheritance for both class- and prototype-based object models. ? The semantics has been included as part of a production JIT-compiler virtual machine. ? The resulting virtual machine has been evaluated to provide significant runtime performance benefits with low memory consumption. ? Our platform supports both Dynamically and statically typed Languages, allowing a direct interoperation between them. ? Backward compatibility with existing. Net applications is maintained. Dynamically typed Languages are becoming increasingly popular for different software development scenarios where runtime adaptability is important. Therefore, existing class-based platforms such as Java and .Net have been gradually incorporating Dynamic features to support the execution of these Languages. The implementations of Dynamic Languages on these platforms commonly generate an extra layer of software over the virtual machine, which reproduces the reflective prototype-based object model provided by most Dynamic Languages. Simulating this model frequently involves a runtime performance penalty, and makes the interoperation between class- and prototype-based Languages difficult.Instead of simulating the reflective model of Dynamic Languages, our approach has been to extend the object-model of an efficient class-based virtual machine with prototype-based semantics, so that it can directly support both kinds of Languages. Consequently, we obtain the runtime performance improvement of using the virtual machine JIT compiler, while a direct interoperation between Languages compiled to our platform is also possible. In this paper, we formalize Dynamic inheritance for both class- and prototype-based Languages, and implement it as an extension of an efficient virtual machine that performs JIT compilation. We also present an extensive evaluation of the runtime performance and memory consumption of the programming language implementations that provide Dynamic inheritance, including ours.
-
Efficient virtual machine support of runtime structural reflection
Science of Computer Programming, 2009Co-Authors: Francisco Ortin, Jose Manuel Redondo, J. Baltasar García Perez-schofieldAbstract:Increasing trends towards adaptive, distributed, generative and pervasive software have made object-oriented Dynamically typed Languages become increasingly popular. These Languages offer Dynamic software evolution by means of reflection, facilitating the development of Dynamic systems. Unfortunately, this dynamism commonly imposes a runtime performance penalty. In this paper, we describe how to extend a production JIT-compiler virtual machine to support runtime object-oriented structural reflection offered by many Dynamic Languages. Our approach improves runtime performance of Dynamic Languages running on statically typed virtual machines. At the same time, existing statically typed Languages are still supported by the virtual machine. We have extended the .Net platform with runtime structural reflection adding prototype-based object-oriented semantics to the statically typed class-based model of .Net, supporting both kinds of programming Languages. The assessment of runtime performance and memory consumption has revealed that a direct support of structural reflection in a production JIT-based virtual machine designed for statically typed Languages provides a significant performance improvement for Dynamically typed Languages.
-
optimizing reflective primitives of Dynamic Languages
International Journal of Software Engineering and Knowledge Engineering, 2008Co-Authors: Jose Manuel Redondo, Francisco Ortin, Juan Manuel CuevaAbstract:Dynamic Languages are becoming widely used in software engineering due to the flexibility needs of specific software systems. Different example scenarios are the development of Dynamic aspect oriented software, Web applications, adaptable and adaptive software or application frameworks. One important lack of these Languages is compile-time error detection offered by static Languages. However, runtime performance is the most serious limitation to use them in commercial software development. Although JIT optimizing compilation is a widely used technique to speed up intermediate code execution, this has not been successfully applied to Dynamically adaptive platforms yet. We present an approach to improve the structural reflective primitives offered by Dynamic Languages. Looking for a language-neutral platform with a good JIT-based runtime performance, we have used the Microsoft shared source implementation of the CLI. Its model has been extended with semantics of prototype-based object-oriented models, much more suitable than the class-based one for reflective environments. This augmented semantics together with JIT generation of native code has produced significantly better runtime performance than the existing implementations.
Daniel Hedin - One of the best experts on this subject based on the ideXlab platform.
-
boosting the permissiveness of Dynamic information flow tracking by testing
European Symposium on Research in Computer Security, 2012Co-Authors: Arnar Birgisson, Daniel Hedin, Andrei SabelfeldAbstract:Tracking information flow in Dynamic Languages remains an open challenge. It might seem natural to address the challenge by runtime monitoring. However, there are well-known fundamental limits of Dynamic flow-sensitive tracking of information flow, where paths not taken in a given execution contribute to information leaks. This paper shows how to overcome the permissiveness limit for Dynamic analysis by a novel use of testing. We start with a program supervised by an information-flow monitor. The security of the execution is guaranteed by the monitor. Testing boosts the permissiveness of the monitor by discovering paths where the monitor raises security exceptions. Upon discovering a security error, the program is modified by injecting an annotation that prevents the same security exception on the next run of the program. The elegance of the approach is that it is sound no matter how much coverage is provided by the testing. Further, we show that when the mechanism has discovered the necessary annotations, then we have an accuracy guarantee: the results of monitoring a program are at least as accurate as flow-sensitive static analysis. We illustrate our approach for a simple imperative language with records and exceptions. Our experiments with the QuickCheck tool indicate that random testing accurately discovers annotations for a collection of scenarios with rich information flows.
-
information flow security for a core of javascript
IEEE Computer Security Foundations Symposium, 2012Co-Authors: Daniel Hedin, Andrei SabelfeldAbstract:Tracking information flow in Dynamic Languages remains an important and intricate problem. This paper makes substantial headway toward understanding the main challenges and resolving them. We identify language constructs that constitute a core of Java Script: objects, higher-order functions, exceptions, and Dynamic code evaluation. The core is powerful enough to naturally encode native constructs as arrays, as well as functionalities of Java Script's API from the document object model (DOM) related to document tree manipulation and event processing. As the main contribution, we develop a Dynamic type system that guarantees information-flow security for this language.
