oalib

Publish in OALib Journal

ISSN: 2333-9721

APC: Only $99

Submit

Any time

2020 ( 4 )

2019 ( 27 )

2018 ( 27 )

2017 ( 20 )

Custom range...

Search Results: 1 - 10 of 15616 matches for " Manuel Carro "
All listed articles are free for downloading (OA Articles)
Page 1 /15616
Display every page Item
An Application of Rational Trees in a Logic Programming Interpreter for a Procedural Language
Manuel Carro
Computer Science , 2004,
Abstract: We describe here a simple application of rational trees to the implementation of an interpreter for a procedural language written in a logic programming language. This is possible in languages designed to support rational trees (such as Prolog II and its descendants), but also in traditional Prolog, whose data structures are initially based on Herbrand terms, but in which implementations often omit the occurs check needed to avoid the creation of infinite data structures. We provide code implementing two interpreters, one of which needs non-occurs-check unification, which makes it faster (and more economic). We provide experimental data supporting this, and we argue that rational trees are interesting enough as to receive thorough support inside the language.
Description and Optimization of Abstract Machines in a Dialect of Prolog
Jose F. Morales,Manuel Carro,Manuel Hermenegildo
Computer Science , 2014, DOI: 10.1017/S1471068414000672
Abstract: In order to achieve competitive performance, abstract machines for Prolog and related languages end up being large and intricate, and incorporate sophisticated optimizations, both at the design and at the implementation levels. At the same time, efficiency considerations make it necessary to use low-level languages in their implementation. This makes them laborious to code, optimize, and, especially, maintain and extend. Writing the abstract machine (and ancillary code) in a higher-level language can help tame this inherent complexity. We show how the semantics of most basic components of an efficient virtual machine for Prolog can be described using (a variant of) Prolog. These descriptions are then compiled to C and assembled to build a complete bytecode emulator. Thanks to the high level of the language used and its closeness to Prolog, the abstract machine description can be manipulated using standard Prolog compilation and optimization techniques with relative ease. We also show how, by applying program transformations selectively, we obtain abstract machine implementations whose performance can match and even exceed that of state-of-the-art, highly-tuned, hand-crafted emulators.
A Program Transformation for Continuation Call-Based Tabled Execution
Pablo Chico de Guzman,Manuel Carro,Manuel V. Hermenegildo
Computer Science , 2009,
Abstract: The advantages of tabled evaluation regarding program termination and reduction of complexity are well known --as are the significant implementation, portability, and maintenance efforts that some proposals (especially those based on suspension) require. This implementation effort is reduced by program transformation-based continuation call techniques, at some efficiency cost. However, the traditional formulation of this proposal by Ramesh and Cheng limits the interleaving of tabled and non-tabled predicates and thus cannot be used as-is for arbitrary programs. In this paper we present a complete translation for the continuation call technique which, using the runtime support needed for the traditional proposal, solves these problems and makes it possible to execute arbitrary tabled programs. We present performance results which show that CCall offers a useful tradeoff that can be competitive with state-of-the-art implementations.
Flow-Injection Flame Atomic Absorption Determination of Hexavalent Chromium with On-Line Preconcentration on an Anion Imprinted Polymer  [PDF]
María Carmen Yebra-Biurrun, Jesús Manuel Castro-Romero, Nieves Carro-Mari?o
American Journal of Analytical Chemistry (AJAC) , 2012, DOI: 10.4236/ajac.2012.311100
Abstract: A flow injection preconcentration system for the flame atomic absorption spectrometric determination of hexavalent chromium has been developed. The method employs on-line preconcentration of Cr(VI) on a minicolumn packed with Cr(VI)-imprinted poly(4-vinyl pyridineco-2-hydroxyethyl methacrylate) placed into a flow injection system. Hexava-lent chromium was eluted with a small volume of diluted hydrochloric acid into the nebulizer-burner system of a flame atomic absorption spectrometer. An enrichment factor of 550 and a 3σ detection limit of 0.04 μg·L-1 along a sampling frequency of 4 h-1 at a sample flow rate of 3.5 mL·min-1. The relative standard deviation is 2.9% for 1 μg·L-1 Cr(VI) (n = 11). The flow injection system proposed has the advantage of being simpler because the use of expensive and sophisticated instruments is avoided. Ease of use, continuous process and selectivity make this method suitable for Cr(VI) determination in different environmental samples such as sea and river waters, soils and sediments.
Swapping Evaluation: A Memory-Scalable Solution for Answer-On-Demand Tabling
Pablo Chico de Guzman,Manuel Carro,David S. Warren
Computer Science , 2010,
Abstract: One of the differences among the various approaches to suspension-based tabled evaluation is the scheduling strategy. The two most popular strategies are local and batched evaluation. The former collects all the solutions to a tabled predicate before making any one of them available outside the tabled computation. The latter returns answers one by one before computing them all, which in principle is better if only one answer (or a subset of the answers) is desired. Batched evaluation is closer to SLD evaluation in that it computes solutions lazily as they are demanded, but it may need arbitrarily more memory than local evaluation, which is able to reclaim memory sooner. Some programs which in practice can be executed under the local strategy quickly run out of memory under batched evaluation. This has led to the general adoption of local evaluation at the expense of the more depth-first batched strategy. In this paper we study the reasons for the high memory consumption of batched evaluation and propose a new scheduling strategy which we have termed swapping evaluation. Swapping evaluation also returns answers one by one before completing a tabled call, but its memory usage can be orders of magnitude less than batched evaluation. An experimental implementation in the XSB system shows that swapping evaluation is a feasible memory-scalable strategy that need not compromise execution speed.
Parallel Backtracking with Answer Memoing for Independent And-Parallelism
Pablo Chico de Guzmán,Amadeo Casas,Manuel Carro,Manuel V. Hermenegildo
Computer Science , 2011,
Abstract: Goal-level Independent and-parallelism (IAP) is exploited by scheduling for simultaneous execution two or more goals which will not interfere with each other at run time. This can be done safely even if such goals can produce multiple answers. The most successful IAP implementations to date have used recomputation of answers and sequentially ordered backtracking. While in principle simplifying the implementation, recomputation can be very inefficient if the granularity of the parallel goals is large enough and they produce several answers, while sequentially ordered backtracking limits parallelism. And, despite the expected simplification, the implementation of the classic schemes has proved to involve complex engineering, with the consequent difficulty for system maintenance and extension, while still frequently running into the well-known trapped goal and garbage slot problems. This work presents an alternative parallel backtracking model for IAP and its implementation. The model features parallel out-of-order (i.e., non-chronological) backtracking and relies on answer memoization to reuse and combine answers. We show that this approach can bring significant performance advantages. Also, it can bring some simplification to the important engineering task involved in implementing the backtracking mechanism of previous approaches.
Lightweight compilation of (C)LP to JavaScript
Jose F. Morales,Rémy Haemmerlé,Manuel Carro,Manuel V. Hermenegildo
Computer Science , 2012, DOI: 10.1017/S1471068412000336
Abstract: We present and evaluate a compiler from Prolog (and extensions) to JavaScript which makes it possible to use (constraint) logic programming to develop the client side of web applications while being compliant with current industry standards. Targeting JavaScript makes (C)LP programs executable in virtually every modern computing device with no additional software requirements from the point of view of the user. In turn, the use of a very high-level language facilitates the development of high-quality, complex software. The compiler is a back end of the Ciao system and supports most of its features, including its module system and its rich language extension mechanism based on packages. We present an overview of the compilation process and a detailed description of the run-time system, including the support for modular compilation into separate JavaScript code. We demonstrate the maturity of the compiler by testing it with complex code such as a CLP(FD) library written in Prolog with attributed variables. Finally, we validate our proposal by measuring the performance of some LP and CLP(FD) benchmarks running on top of major JavaScript engines.
Towards Execution Time Estimation for Logic Programs via Static Analysis and Profiling
Edison Mera,Pedro Lopez-Garcia,German Puebla,Manuel Carro,Manuel Hermenegildo
Computer Science , 2007,
Abstract: Effective static analyses have been proposed which infer bounds on the number of resolutions or reductions. These have the advantage of being independent from the platform on which the programs are executed and have been shown to be useful in a number of applications, such as granularity control in parallel execution. On the other hand, in distributed computation scenarios where platforms with different capabilities come into play, it is necessary to express costs in metrics that include the characteristics of the platform. In particular, it is specially interesting to be able to infer upper and lower bounds on actual execution times. With this objective in mind, we propose an approach which combines compile-time analysis for cost bounds with a one-time profiling of the platform in order to determine the values of certain parameters for a given platform. These parameters calibrate a cost model which, from then on, is able to compute statically time bound functions for procedures and to predict with a significant degree of accuracy the execution times of such procedures in the given platform. The approach has been implemented and integrated in the CiaoPP system.
Un siglo de cine en América Latina
Nelson Carro
Política y cultura , 1997,
Abstract:
Revista de Revistas.
Susana Carro
Revista de la Asociación Espa?ola de Neuropsiquiatría , 1986,
Abstract: Sin resumen.
Page 1 /15616
Display every page Item


Home
Copyright © 2008-2017 Open Access Library. All rights reserved.