71 research outputs found
Proyecto plantas medicinales - Universidad del Valle
No full text<p>Proyecto plantas medicinales.</p>
<p>Jorge H. Ramírez</p>
<p>Universidad del Valle</p>
<p>--</p>
<p>Dec 10, 2014.</p>
<p>Co-author added: Atanas Atanasov. University of Vienna. </p>
<p> </p
Enhancing the spectator experience: Integrating subtitle display in eXtended reality theatres
No full textThe rapid growth of virtual and augmented reality technologies,
encapsulated by the term eXtended Reality (XR), has revolutionized
the interaction with digital content, bringing new opportunities for
entertainment and communication. Subtitles and closed captions
are crucial in improving language learning, vocabulary acquisition,
and accessibility, like understanding audiovisual content. However,
little is known about integrating subtitle displays in extended re-
ality theatre environments and their experience influence on the
user. This study addresses this gap by examining subtitle placement
and design attributes specific to XR settings. Building on previous
research on subtitle placement, mainly in television and 360-degree
videos, this project focuses on the differences between static and dy-
namic subtitle variants. The study uses a comprehensive literature
review, Virtual Reality (VR) theatre experiment, and analytics to
investigate these aspects of subtitle integration in the specific case
of a VR theatrical Greek play with subtitles. The results show that
the comparison between the two variants is insignificant, and both
implementations produce high scores. However, thematic analysis
suggests the preference for static over the dynamic variant depends
heavily on the specific context and the number of speakers in the
scene. Since this study focuses on a monologue theatrical play, the
next step in future work would be to explore a "multi-speaker" play
Practical Points-to Analysis for Programs Built with Libraries
No full textTraditional whole-program analysis cannot be directly applied to programs that include precompiled libraries. Such programs could be analyzed separately from the included libraries by using precomputed summary information about each library. This paper describes one such separate analysis derived from Andersen’s whole program points-to analysis. The analysis uses a summary which is a compact representation of the points-to effects of all statements in the library. The summary is generated by substituting some of the library variables with placeholder variables. By replacing many variables with the same placeholder, we can reduce the size of the summary and the cost of the separate analysis. We use a substitution which summarizes the library effects without losing precision or exposing the internals of the library. Our experiments show that the cost of computing and storing the summary is practical, and that the substitution technique significantly reduces the cost of the separate analysis.Technical report DCS-TR-41
Points-to and Side-effect Analyses for Programs Built with Precompiled Libraries
No full textLarge programs are typically built from separate modules. Traditional whole-program analysis cannot be used in the context of such modular development. In this paper we consider analysis for programs that combine client modules with precompiled library modules. We define separate analyses that allow library modules and client modules to be analyzed separately from each other. Our target analyses are Andersen's points-to analysis and a side-effect analysis based on it. We perform separate points-to and side-effect analyses of a library module by using worst-case assumptions about the rest of the program. We also show how to construct summary information about a library module and how to use it for separate analysis of client modules. We present empirical results showing that the separate points-to analyses are practical even for large modules, and that the cost of constructing and storing library summaries is low. Our work is a step toward incorporating practical points-to and side-effect analyses in realistic compilers and software productivity tools.Technical report DCS-TR-42
Points-to analysis for Java based on annotated constraints
No full textThe goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. In this paper we present a points-to analysis for Java based on Andersen’s points-to analysis for C [5]. Andersen’s analysis can be implemented efficiently by using systems of set-inclusion constraints and by employing several techniques for constraint representation and resolution. We extend these techniques to efficiently represent and solve systems of annotated inclusion constraints. The annotations play two roles in our analysis. Method annotations are used to model precisely and efficiently the semantics of virtual calls. Field annotations allow us to distinguish between different fields of an object. In addition, our analysis keeps track of all reachable methods and avoids analyzing irrelevant library code. We evaluate the performance of the analysis on a large set of realistic Java programs. Our experiments show that the analysis runs in practical time and space, and has significant impact on call graph construction, virtual call resolution, synchronization removal, stack-based object allocation, and object read-write information. The results show that our analysis is a realistic candidate for a relatively precise, practical, general-purpose points-to analysis for Java.Technical report DCS-TR-42
Precise Call Graph Construction in the Presence of Function Pointers
No full textThe use of pointers creates serious problems for optimizing compilers and software engineering tools. Pointers enable indirect memory accesses through pointer dereferences, as well as indirect procedure calls (e.g., through function pointers in C). Such indirect accesses and calls can be disambiguated with pointer analysis. In this paper we evaluate the precision of a pointer analysis by Zhang et al. [17] for the purposes of call graph construction for C programs with function pointers. The analysis uses an inexpensive, almost-linear, flow- and context-insensitive algorithm. To measure analysis precision, we compare the call graph computed by the analysis with the most precise call graph obtainable by a large category of pointer analyses. Surprisingly, for all our data programs the analysis from [17] achieves the best possible precision. This result indicates that for the purposes of call graph construction, even inexpensive analyses can provide very good precision, and therefore the use of more expensive analyses may not be justified.Technical report DCS-TR-44
Points-to analysis for Java using annotated inclusion constraints
No full textThe goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. In this paper we define and evaluate a points-to analysis for Java which extends Andersen’s points-to analysis for C [4]. Andersen’s analysis for C can be implemented efficiently by using systems of set-inclusion constraints and by employing several techniques for constraint representation and resolution. We extend these techniques to efficiently represent and solve systems of annotated inclusion constraints. The annotations play two roles in our analysis. Method annotations are used to model precisely and efficiently the semantics of virtual calls. Field annotations allow us to distinguish the flow of values through different fields of an object. In addition, our analysis keeps track of all methods reachable from the entry point of the program, and avoids analyzing dead library code. We evaluate the performance of the analysis on a large set of realistic Java programs. Our results show that the analysis is practical and therefore will be useful as a relatively precise general-purpose points-to analysis for Java. The experiments also show that the points-to solution has significant impact on call graph construction, virtual call resolution, elimination of unnecessary synchronization, and stack-based object allocation.Technical report DCS-TR-41
Parameterized object sensitivity for points-to and side-effect analyses for Java
No full textThe goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. Improving the precision of practical points-to analysis is important because points-to information has a wide variety of client applications in optimizing compilers and software engineering tools. In this paper we present object sensitivity, a new approach to context-sensitive flow insensitive points-to analysis for Java. The key idea of our approach is to analyze a method separately for each of the objects on which this method is invoked. To ensure flexibility and practicality, we propose a parameterization framework which allows analysis designers to control the cost precision tradeoffs of the object-sensitive analysis. Side-effect analysis determines the memory locations that can be modified by the execution of a program statement. This information is needed for various compiler optimizations and software engineering tools. We present a new form of side-effect analysis for Java which is based on object sensitive points-to analysis. We have implemented one instantiation of our parameterized object-sensitive points-to analysis. We compare this instantiation with a context-insensitive points-to analysis for Java which is based on Andersen’s analysis for C [4]. On a set of 23 realistic Java programs, our experiments show that the two analyses have comparable cost. In some cases the object-sensitive analysis is actually faster than the context sensitive analysis. Our results also show that object sensitivity significantly improves the precision of side-effect analysis, call graph construction, and virtual call resolution. Our empirical results demonstrate that object-sensitive analyses are capable of achieving significantly better precision than context-insensitive ones, while at the same time remaining efficient and practical. Thus, object-sensitive analysis is a better candidate for a relatively precise, practical, general-purpose points-to analysis for Java.Technical report DCS-TR-47
Fragment class analysis for testing of polymorphism in Java software
No full textAdequate testing of polymorphism in object-oriented software requires coverage of all possible bindings of receiver classes and target methods at call sites. Tools that measure this coverage need to use class analysis to compute the coverage requirements. However, traditional whole-program class analysis cannot be used when testing partial programs. To solve this problem, we present a general approach for adapting whole-program class analyses to operate on program fragments. Furthermore, since analysis precision is critical for coverage tools, we provide precision measurements for several analyses by determining which of the computed coverage requirements are actually feasible. Our work enables the use of whole-program class analyses for testing of polymorphism in partial programs, and identifies analyses that compute precise coverage requirements and therefore are good candidates for use in coverage tools.Technical report DCS-TR-50
Data-Flow Analysis of Program Fragments
No full textTraditional interprocedural data-flow analysis is performed on whole programs; however, such whole-program analysis is not feasible for large or incomplete programs. We propose fragment data-flow analysis as an alternative analysis approach, which addresses the problem of computing data-flow information for a specific program fragment. The analysis is parameterized by the additional information available about the rest of the program. We describe two frameworks for interprocedural flow-sensitive fragment analysis, the relationship between fragment analysis and whole-program analysis, and the requirements ensuring fragment analysis safety and feasibility. We propose an application of fragment analysis as a second analysis phase after an inexpensive flowinsensitive whole-program analysis, in order to obtain better information for important program fragments. We also describe the design of two fragment analyses derived from an already existing whole-program flowand context-sensitive pointer alias analysis for C programs and present empirical evaluation of their cost and precision. Our experiments show evidence of dramatically better precision obtainable at a practical cost.Technical report DCS-TR-38
- …
