220 research outputs found
ORCSolver: An Efficient Solver for Adaptive GUI Layout with OR-Constraints
OR-constrained (ORC) graphical user interface layouts unify conventional
constraint-based layouts with flow layouts, which enables the definition of
flexible layouts that adapt to screens with different sizes, orientations, or
aspect ratios with only a single layout specification. Unfortunately, solving
ORC layouts with current solvers is time-consuming and the needed time
increases exponentially with the number of widgets and constraints. To address
this challenge, we propose ORCSolver, a novel solving technique for adaptive
ORC layouts, based on a branch-and-bound approach with heuristic preprocessing.
We demonstrate that ORCSolver simplifies ORC specifications at runtime and our
approach can solve ORC layout specifications efficiently at near-interactive
rates.Comment: Published at CHI202
AUTOMATING DATA-LAYOUT DECISIONS IN DOMAIN-SPECIFIC LANGUAGES
A long-standing challenge in High-Performance Computing (HPC) is the simultaneous achievement of programmer productivity and hardware computational efficiency. The challenge has been exacerbated by the onset of multi- and many-core CPUs and accelerators. Only a few expert programmers have been able to hand-code domain-specific data transformations and vectorization schemes needed to extract the best possible performance on such architectures. In this research, we examined the possibility of automating these methods by developing a Domain-Specific Language (DSL) framework. Our DSL approach extends C++14 by embedding into it a high-level data-parallel array language, and by using a domain-specific compiler to compile to hybrid-parallel code. We also implemented an array index-space transformation algebra within this high-level array language to manipulate array data-layouts and data-distributions. The compiler introduces a novel method for SIMD auto-vectorization based on array data-layouts. Our new auto-vectorization technique is shown to outperform the default auto-vectorization strategy by up to 40% for stencil computations. The compiler also automates distributed data movement with overlapping of local compute with remote data movement using polyhedral integer set analysis. Along with these main innovations, we developed a new technique using C++ template metaprogramming for developing embedded DSLs using C++. We also proposed a domain-specific compiler intermediate representation that simplifies data flow analysis of abstract DSL constructs. We evaluated our framework by constructing a DSL for the HPC grand-challenge domain of lattice quantum chromodynamics. Our DSL yielded performance gains of up to twice the flop rate over existing production C code for selected kernels. This gain in performance was obtained while using less than one-tenth the lines of code. The performance of this DSL was also competitive with the best hand-optimized and hand-vectorized code, and is an order of magnitude better than existing production DSLs.Doctor of Philosoph
A Graphical Environment Supporting the Algebraic Specification of Abstract Data Types
Abstract Data Types (ADTs) are a powerful conceptual and practical device for building high-quality software because of the way they can describe objects whilst hiding the details of how they are represented within a computer. In order to implement ADTs correctly, it is first necessary to precisely describe their properties and behaviour, typically within a mathematical framework such as algebraic specification. These techniques are no longer merely research topics but are now tools used by software practitioners. Unfortunately, the high level of mathematical sophistication required to exploit these methods has made them unattractive to a large portion of their intended audience. This thesis investigates the use of computer graphics as a way of making the formal specification of ADTs more palatable. Computer graphics technology has recently been explored as a way of making computer programs more understandable by revealing aspects of their structure and run-time behaviour that are usually hidden in textual representations. These graphical techniques can also be used to create and edit programs. Although such visualisation techniques have been incorporated into tools supporting several phases of software development, a survey presented in this thesis of existing systems reveals that their application to supporting the formal specification of ADTs has so far been ignored. This thesis describes the development of a prototype tool (called VISAGE) for visualising and visually programming formally-specified ADTs. VISAGE uses a synchronised combination of textual and graphical views to illustrate the various facets of an ADT's structure and behaviour. The graphical views use both static and dynamic representations developed specifically for this domain. VISAGE's visual programming facility has powerful mechanisms for creating and manipulating entire structures (as well as their components) that make it at least comparable with textual methods. In recognition of the importance of examples as a way of illustrating abstract concepts, VISAGE provides a dedicated tool (called the PLAYPEN) that allows the creation of example data by the user. These data can then be transformed by the operations belonging to the ADT with the result shown by means of a dynamic, graphical display. An evaluation of VISAGE was conducted in order to detect any improvement in subjects' performance, confidence and understanding of ADT specifications. The subjects were asked to perform a set of simple specification tasks with some using VISAGE and the others using manual techniques to act as a control. An analysis of the results shows a distinct positive reaction from the VISAGE group that was completely absent in the control group thereby supporting the thesis that the algebraic specification of ADTs can be made more accessible and palatable though the use of computer graphic techniques
Generating Programming Environments with Integrated Text and Graphics for VLSI Design Systems
The constant improvements in device integration, the development of new technologies
and the emergence of new design techniques call for flexible, maintainable
and robust software tools. The generic nature of compiler-compiler systems,
with their semi-formal specifications, can help in the construction of those tools.
This thesis describes the Wright editor generator which is used in the synthesis
of language-based graphical editors (LBGEs). An LBGE is a programming
environment where the programs being manipulated denote pictures. Editing
actions can be specified through both textual and graphical interfaces. Editors
generated by the Wright system are specified using the formalism of attribute
grammars.
The major example editor in this thesis, Stick-Wright, is a design entry system
for the construction of VLSI circuits. Stick-Wright is a hierarchical symbolic
layout editor which exploits a combination of text and graphics in an interactive
environment to provide the circuit designer with a tool for experimenting with
circuit topologies. A simpler system, Pict-Wright: a picture drawing system, is
also used to illustrate the attribute grammar specification process.
This thesis aims to demonstrate the efficacy of formal specification in the
generation of software-tools. The generated system Stick-Wright shows that a
text/graphic programming environment can form the basis of a powerful VLSI
design tool, especially with regard to providing the designer with immediate
graphical feedback. Further applications of the LBGE generator approach to
system design are given for a range of VLSI design activities
ORC Layout: Adaptive GUI Layout with OR-Constraints
We propose a novel approach for constraint-based graphical user interface
(GUI) layout based on OR-constraints (ORC) in standard soft/hard linear
constraint systems. ORC layout unifies grid layout and flow layout, supporting
both their features as well as cases where grid and flow layouts individually
fail. We describe ORC design patterns that enable designers to safely create
flexible layouts that work across different screen sizes and orientations. We
also present the ORC Editor, a GUI editor that enables designers to apply ORC
in a safe and effective manner, mixing grid, flow and new ORC layout features
as appropriate. We demonstrate that our prototype can adapt layouts to screens
with different aspect ratios with only a single layout specification, easing
the burden of GUI maintenance. Finally, we show that ORC specifications can be
modified interactively and solved efficiently at runtime
Recommended from our members
Formalizing graphical notations
The thesis describes research into graphical notations for software engineering, with a principal interest in ways of formalizing them. The research seeks to provide a theoretical basis that will help in designing both notations and the software tools that process them.
The work starts from a survey of literature on notation, followed by a review of techniques for formal description and for computational handling of notations. The survey concentrates on collecting views of the benefits and the problems attending notation use in software development; the review covers picture description languages, grammars and tools such as generic editors and visual programming environments. The main problem of notation is found to be a lack of any coherent, rigorous description methods. The current approaches to this problem are analysed as lacking in consensus on syntax specification and also lacking a clear focus on a defined concept of notated expression.
To address these deficiencies, the thesis embarks upon an exploration of serniotic, linguistic and logical theory; this culminates in a proposed formalization of serniosis in notations, using categorial model theory as a mathematical foundation. An argument about the structure of sign systems leads to an analysis of notation into a layered system of tractable theories, spanning the gap between expressive pictorial medium and subject domain. This notion of 'tectonic' theory aims to treat both diagrams and formulae together.
The research gives details of how syntactic structure can be sketched in a mathematical sense, with examples applying to software development diagrams, offering a new solution to the problem of notation specification. Based on these methods, the thesis discusses directions for resolving the harder problems of supporting notation design, processing and computer-aided generic editing. A number of future research areas are thereby opened up. For practical trial of the ideas, the work proceeds to the development and partial implementation of a system to aid the design of notations and editors. Finally the thesis is evaluated as a contribution to theory in an area which has not attracted a standard approach
Polygon packing approach to disconnected graph layout
Cataloged from PDF version of article.Graph layout has become an important area of research in Computer Science for the last couple of
decades. There is a wide range of applications for graph layout including data structures, databases,
software engineering, VLSI technology, electrical engineering, production planning, chemistry, and
biology. Most layout algorithms assume the graph to be connected. However, most graphs are
disconnected and a method for putting the disconnected graph objects together is needed.
Two-dimensional packing algorithms have wide area of application such as in the steel and textile
industry. In steel industry, problems frequently occur when the need to stamp polygonal figures from a
rectangular board arises. In the textile industry, similar problems exist. The aim is same: to maximize the
use of the contiguous remainder of the board.
Recently, two-dimensional packing has also been used in disconnected graph layout yielding algorithms
that ‘tile’ the disconnected graph objects, which are represented by rectangles. These algorithms are also
required to respect the specified aspect ratio for the final layout. A more recent approach to disconnected
graph layout has been the use of polyominoes for representing the graph objects resulting in more
accurate packings at the cost of increased execution times.
In this thesis, we use polygons for a more accurate representation of graph objects and present new
algorithms for disconnected graph layout. Specifically, we apply the No-Fit Polygon approach in twodimensional
packing to disconnected graph layout. We present and analyze the graph layouts resulting
from our new approach and contrast the new approach with previous ones.Başköy, CihadM.S
Doctor of Philosophy
dissertationInteractive editing and manipulation of digital media is a fundamental component in digital content creation. One media in particular, digital imagery, has seen a recent increase in popularity of its large or even massive image formats. Unfortunately, current systems and techniques are rarely concerned with scalability or usability with these large images. Moreover, processing massive (or even large) imagery is assumed to be an off-line, automatic process, although many problems associated with these datasets require human intervention for high quality results. This dissertation details how to design interactive image techniques that scale. In particular, massive imagery is typically constructed as a seamless mosaic of many smaller images. The focus of this work is the creation of new technologies to enable user interaction in the formation of these large mosaics. While an interactive system for all stages of the mosaic creation pipeline is a long-term research goal, this dissertation concentrates on the last phase of the mosaic creation pipeline - the composition of registered images into a seamless composite. The work detailed in this dissertation provides the technologies to fully realize interactive editing in mosaic composition on image collections ranging from the very small to massive in scale
Sequential decomposition of operations and compilers optimization
Code optimization is an important area of research that has remarkable contributions in addressing the challenges of information technology. It has introduced a new trend in hardware as well as in software. Efforts that have been made in this context led to introduce a new foundation, both for compilers and processors. In this report we study different techniques used for sequential decomposition of mappings without using extra variables. We focus on finding and improving these techniques of computations. Especially, we are interested in developing methods and efficient heuristic algorithms to find the decompositions and implementing these methods in particular cases. We want to implement these methods in a compiler with an aim of optimizing code in machine language. It is always possible to calculate an operation related to K registers by a sequence of assignments using only these K registers. We verified the results and introduced new methods. We described In Situ computation of linear mapping by a sequence of linear assignments over the set of integers and investigated bound for the algorithm. We introduced a method for the case of boolean bijective mappings via algebraic operations over polynomials in GF(2). We implemented these methods using Mapl
- …