A methodology for granularity-based control of parallelism in logic programs

Several types of parallelism can be exploited in logic programs while preserving correctness and efficiency, i.e. ensuring that the parallel execution obtains the same results as the sequential one and the amount of work performed is not greater. However, such results do not take into account a number of overheads which appear in practice, such as process creation and scheduling, which can induce a slow-down, or, at least, limit speedup, if they are not controlled in some way. This paper describes a methodology whereby the granularity of parallel tasks, i.e. the work available under them, is efficiently estimated and used to limit parallelism so that the effect of such overheads is controlled. The run-time overhead associated with the approach is usually quite small, since as much work is done at compile time as possible. Also,a number of run-time optimizations are proposed. Moreover, a static analysis of the overhead associated with the granularity control process is performed in order to decide its convenience. The performance improvements resulting from the incorporation of grain size control are shown to be quite good, specially for systems with medium to large parallel execution overheads.

Effect of hen age, egg weight and storage system on physical properties of egg from white-egg laying hens

A total of 72 eggs from a group of 100 white laying hens housed in standard cages were analyzed. Thirty-six eggs were retired when the hens had 44 week of age and the other 36 eggs were retired eight weeks afterwards. Each group of 36 eggs was radomly divided in three groups of 12 eggs. First group was analyzed at once (storage system C); second one was kept during one week in the refrigerator (5ºC) (storage system R), and third group were kept also one week but on ambient temperature (25ºC) (storage system ET). The hen age, egg weight and storage system had not significant (P>0.05) effect on shell thickness. The specific gravity (SG) has a positive relation with shell quality. The egg class and storage system significantly (P<0,05) affected to SG, while no influence of bird age on this variable was observed. The yolk color increased with hen age but storage system had not effect on this variable. The increase of the hen age and the R and AT storage systems significantly (P<0.05) reduced albumen height (H) and the interaction hen age x storage system was significant (P<0.025) for this variable. The reduction of the H due to R and ET storage systems was higher in the eggs from hens with 52 weeks of age than in those from hens with 44 weeks of age. The Haugh units (HU) was significantly (P<0.05) affected by hen age, egg class and storage system. The hen age increase reduced HU and the R and ET eggs had lower HU than C eggs. It is concluded that the bird age and storage system with high temperatures reduced the egg quality.

Effect of bird age and storage system on physical properties of eggs from brown laying hens

A total of 108 eggs from a group of 100 brown laying hens housed in standard cages were analyzed. Thirty-six eggs were retired when the hens had 30 week of age, other 36 eggs were retired when the hens had 35 week of age and the remaining 36 eggs were retired five weeks afterwards. Each group of 36 eggs was radomly divided in three groups of 12 eggs. First group was analyzed at once, second group one was kept during one week in the refrigerator (5°C) and third group was kept also one week but on ambient temperature (25°C). Shell color, shell thickness, specific gravity, albumen height and Haugh units wre obtained. The bird age had significant effect on shell color and shell thickness, but the storage system had not influence on such variables. The hen age had not effect on specific gravity, but the storage system affected to this variable. Hen age and storage system had significant influence (P<0.05) on albumen height and Haugh units, and the interaction age × storage system was significant for these variables. The specific gravity had positive relations with shell thickness, yolk color, albumen height and Haugh units. It is concluded that bird age and storage system under high temperatures reduced the egg quality.

Global flow analysis as a practical compilation tool

This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of speed of the analysis, precisión, and usefulness of the information obtained. To this end, design and implementation aspects are discussed for two practical abstract interpretation-based flow analysis systems: MA , the MCC And-parallel Analyzer and Annotator; and Ms, an experimental mode inference system developed for SB-Prolog. The paper also provides performance data obtained (rom these implementations and, as an example of an application, a study of the usefulness of the mode information obtained in reducing run-time checks in independent and-parallelism.Based on the results obtained, it is concluded that the overhead of global flow analysis is not prohibitive, while the results of analysis can be quite precise and useful.

Multivariant non-failure analysis via standard abstract interpretation

Non-failure analysis aims at inferring that predicate calis in a program will never fail. This type of information has many applications in functional/logic programming. It is essential for determining lower bounds on the computational cost of calis, useful in the context of program parallelization, instrumental in partial evaluation and other program transformations, and has also been used in query optimization. In this paper, we re-cast the non-failure analysis proposed by Debray et al. as an abstract interpretation, which not only allows to investígate it from a standard and well understood theoretical framework, but has also several practical advantages. It allows us to incorpórate non-failure analysis into a standard, generic abstract interpretation engine. The analysis thus benefits from the fixpoint propagation algorithm, which leads to improved information propagation. Also, the analysis takes advantage of the multi-variance of the generic engine, so that it is now able to infer sepárate non-failure information for different cali patterns. Moreover, the implementation is simpler, and allows to perform non-failure and covering analyses alongside other analyses, such as those for modes and types, in the same framework. Finally, besides the precisión improvements and the additional simplicity, our implementation (in the Ciao/CiaoPP multiparadigm programming system) also shows better efRciency.

Lower bound cost estimation for logic programs

It is generally recognized that information about the runtime cost of computations can be useful for a variety of applications, including program transformation, granularity control during parallel execution, and query optimization in deductive databases. Most of the work to date on compile-time cost estimation of logic programs has focused on the estimation of upper bounds on costs. However, in many applications, such as parallel implementations on distributed-memory machines, one would prefer to work with lower bounds instead. The problem with estimating lower bounds is that in general, it is necessary to account for the possibility of failure of head unification, leading to a trivial lower bound of 0. In this paper, we show how, given type and mode information about procedures in a logic program, it is possible to (semi-automatically) derive nontrivial lower bounds on their computational costs. We also discuss the cost analysis for the special and frequent case of divide-and-conquer programs and show how —as a pragmatic short-term solution —it may be possible to obtain useful results simply by identifying and treating divide-and-conquer programs specially.

Non-failure analysis for logic programs

We provide a method whereby, given mode and (upper approximation) type information, we can detect procedures and goals that can be guaranteed to not fail (i.e., to produce at least one solution or not termínate). The technique is based on an intuitively very simple notion, that of a (set of) tests "covering" the type of a set of variables. We show that the problem of determining a covering is undecidable in general, and give decidability and complexity results for the Herbrand and linear arithmetic constraint systems. We give sound algorithms for determining covering that are precise and efiicient in practice. Based on this information, we show how to identify goals and procedures that can be guaranteed to not fail at runtime. Applications of such non-failure information include programming error detection, program transiormations and parallel execution optimization, avoiding speculative parallelism and estimating lower bounds on the computational costs of goals, which can be used for granularity control. Finally, we report on an implementation of our method and show that better results are obtained than with previously proposed approaches.

Towards granularity based control of parallelism in logic programs

Several types of parallelism can be exploited in logic programs while preserving correctness and efficiency, i.e. ensuring that the parallel execution obtains the same results as the sequential one and the amount of work performed is not greater. However, such results do not take into account a number of overheads which appear in practice, such as process creation and scheduling, which can induce a slow-down, or, at least, limit speedup, if they are not controlled in some way. This paper describes a methodology whereby the granularity of parallel tasks, i.e. the work available under them, is efficiently estimated and used to limit parallelism so that the effect of such overheads is controlled. The run-time overhead associated with the approach is usually quite small, since as much work is done at compile time as possible. Also, a number of run-time optimizations are proposed. Moreover, a static analysis of the overhead associated with the granularity control process is performed in order to decide its convenience. The performance improvements resulting from the incorporation of grain size control are shown to be quite good, specially for systems with médium to large parallel execution overheads.

Task granularity analysis in logic programs

While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a sepárate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.

Estimating the computational cost of logic programs

Information about the computational cost of programs is potentially useful for a variety of purposes, including selecting among different algorithms, guiding program transformations, in granularity control and mapping decisions in parallelizing compilers, and query optimization in deductive databases. Cost analysis of logic programs is complicated by nondeterminism: on the one hand, procedures can return múltiple Solutions, making it necessary to estímate the number of solutions in order to give nontrivial upper bound cost estimates; on the other hand, the possibility of failure has to be taken into account while estimating lower bounds. Here we discuss techniques to address these problems to some extent.

Opera omnia / Gasparis Baetiae ...

Texto e índice a dos col.

Cautele Bartho [et] Cepolle : Incipiu[n]t sole[m]nes ac p[er]utiles tractatus memoriaq[ue] ac studio dignissimi egregij viri ... Bartholomei Cepolle videlicet.

Texto e índices a dos col. con apostillas marginales

Transformation�based implementation and optimization of programs exploiting the basic Andorra model.

The characteristics of CC and CLP systems are in principle very dierent However a recent trend towards convergence in the implementation techniques for these systems can be observed While CLP and Prolog systems have been incorporating capabilities to deal with userdened suspension and coroutining CC compilers have been trying to coalesce negrained tasks into coarsergrained sequential threads This convergence of techniques opens up the possibility of having a general purpose kernel language and abstract machine to serve as a compilation target for a variety of userlevel languages We propose a transformation technique directed towards such an objective In particular we report on techniques to support the Andorra computational model essentially emulating the AndorraI system via program transformation into a sequential language with delay primitives The system is automatic comprising an optional program analyzer and a basic transformer to the kernel language It turns out that a simple parallel CLP or Prolog system with dynamic scheduling is sucient as a kernel language for this purpose The preliminary results are quite encouraging performance of the resulting system is comparable to the current AndorraI implementation.

Protección catódica en estructuras sumergidas. Aplicación al proyecto de boyas y tuberías de un terminal portuario de descarga de crudo.

Este proyecto tiene por objeto el diseño de la protección catódica contra la corrosión de las boyas y las tuberías sumergidas en agua de mar de un terminal portuario de descarga de crudo. La protección catódica consiste en la igualación de los potenciales de las áreas anódicas y catódicas del material por el flujo de electrones suministrado. En el proyecto se han empleado los métodos de ánodos de sacrificio y de corriente impresa para analizar la protección catódica más adecuada de cada componente. Para los cálculos de los ánodos necesarios para la protección catódica se utilizó el procedimiento de la masa, seleccionando así el método, ánodos de sacrificio o corriente impresa, y los ánodos más apropiados para la protección catódica de las boyas y de las tuberías. ABSTRACT The aim of this project was to design the cathodic protection against corrosion of a crude oil unloading port terminal’s buoys and under sea water pipelines. The cathodic protection consists in the equating of anodic and cathodic material areas by the electrons flow supplied. In this project, sacrificial anodes and impressed current methods were used for analyze the most suitable cathodic protection for each component. For the cathodic protection required anodes calculations, the weight procedure was used, thereby selecting the method, sacrificial anodes or impressed current, and the most appropriate anodes, for the cathodic protection of the buoys and pipelines