bluuebunny/crossref_metadata_2025 huggingface dataset:
Costs of living for juvenile Chinook salmon (Oncorhynchus tshawytscha) in an increasingly warming and invaded world
Authors: Kuehne Lauren M. , Olden Julian D. , Duda Jeffrey J.
Published: October 2012

Rapid environmental change in freshwater ecosystems has created a need to understand the interactive effects of multiple stressors, with temperature and invasive predators identified as key threats to imperiled fish species. We tested the separate and interactive effects of water temperature and predation by non-native smallmouth bass ( Micropterus dolomieu ) on the lethal (mortality) and sublethal (behavior, physiology, and growth) effects for juvenile Chinook salmon ( Oncorhynchus tshawytscha ) in seminatural stream channel experiments. Over 48 h trials, there was no difference in direct predation with warmer temperatures, but significant interactive effects on sublethal responses of juvenile salmon. Warmer temperatures resulted in significantly stronger and more variable antipredator responses (surface shoaling and swimming activity), while physiological indicators (plasma glucose, plasma cortisol) suggested suppression of physiological mechanisms in response to the combined stressors. These patterns corresponded with additive negative growth in predation, temperature, and combined treatments. Our results suggest that chronic increases in temperature may not increase direct predation over short periods, but can result in significant sublethal costs with negative implications for long-term development, disease resistance, and subsequent size-selective mortality of Pacific salmon.
Direct Current and Microwave Characteristics of Sub-micron AlGaN/GaN High-Electron-Mobility Transistors on 8-Inch Si(111) Substrate
Authors: Arulkumaran Subramaniam , Ng Geok Ing , Vicknesh Sahmuganathan , Wang Hong , Ang Kian Siong , Tan Joyce Pei Ying , Lin Vivian Kaixin , Todd Shane , Lo Guo-Qiang , Tripathy Sudhiranjan
Published: October 2012

We report for the first time the DC and microwave characteristics of sub-micron gate (∼0.3 µm) AlGaN/GaN high-electron-mobility transistors (HEMTs) on 8-in. diameter Si(111) substrate. The fabricated sub-micron gate devices on crack-free AlGaN/GaN HEMT structures exhibited good pin.-off characteristics with a maximum drain current density of 853 mA/mm and a maximum extrinsic transconductance of 180 mS/mm. The device exhibited unit current-gain cut-off frequency of 28 GHz, maximum oscillation frequency of 64 GHz and OFF-state breakdown voltage of 60 V. This work demonstrates the feasibility of achieving good performance AlGaN/GaN HEMTs on 8-in. diameter Si(111) for low-cost high-frequency and high-power switching applications.
Fourier Transform Infrared Spectroscopy of Low-k Dielectric Material on Patterned Wafers
Authors: Lam Jeffrey Chorkeung , Tan Hao , Huang Maggie Yamin , Zhang Fan , Sun Handong , Shen Zexiang , Mai Zhihong
Published: October 2012

With many of research on Fourier transform IR (FTIR) on low-k materials, our experiments extended the FTIR spectroscopy application to characterization and analysis of the low-k dielectric thin film properties on patterned wafers. FTIR spectra on low-k materials were successfully captured under three sampling modes: reflection, attenuated total reflectance (ATR), and mapping mode. ATR mode is more suitable for CH
x
band than reflection mode due to its higher sensitivity in this range. FTIR spectroscopy signal analysis on mixed structures (metal and low-k dielectric material) on patterned wafers was also investigated with mapping mode. Based on our investigation, FTIR can be used for low-k material studies on patterned wafer.
High Stability and Efficiency of GaN Photocatalyst for Hydrogen Generation from Water
Authors: Hayashi Tomoe , Deura Momoko , Ohkawa Kazuhiro
Published: October 2012

Continuous hydrogen generation from water was realized for 110 h using an n-type GaN film with a NiO cocatalyst. This GaN–NiO photocatalyst exhibits incident photon-to-current conversion efficiencies of 70 and 57% at wavelengths of 300 and 350 nm, respectively. These results indicate that the GaN–NiO photocatalyst has high stability and efficiency for hydrogen generation.
Effects of Sb/As Interdiffusion on Optical Anisotropy of GaSb Quantum Dots in GaAs Grown by Droplet Epitaxy
Authors: Kawazu Takuya , Noda Takeshi , Mano Takaaki , Sakuma Yoshiki , Sakaki Hiroyuki
Published: October 2012

We studied the effects of Sb/As interdiffusion on the optical anisotropy of GaSb quantum dots (QDs) in GaAs. GaSb QDs were grown by droplet epitaxy, and their shape is slightly elongated along [11̄0]. Polarized photoluminescence (PL) studies showed that the PL is polarized preferentially along [11̄0]. To induce the Sb/As interdiffusion, a post-growth annealing was performed at T
a = 600–950 °C. As T
a increases, the degree of polarization (DOP) drastically decreases. The experimental results were compared with a theoretical model. The DOP reduction is explained by considering the optical anisotropy of the ground and first excited states, where the contribution of the excited state increases as the diffusion proceeds.
In-situ Evaluation of Air/Oxygen Percentage Variation by Introducing 1,1,1,3,3-Pentafluoropropane in Ultraviolet Nanoimprint Lithography
Authors: Wang Qing , Hiroshima Hiroshi , Suzuki Kenta , Youn Sung-Won
Published: October 2012

In UV nanoimprinting, the air percentage is critical to the generation of bubble defects in nanoimprinted samples. In this work, it is found that as the pentafluoropropane gas (CHF2CH2CF3; 1,1,1,3,3-pentafluoropropane, HFC-245fa, CAS No. 460-3-1) is introduced, the air percentage rapidly decreases from 100% to a stable low level of 8%. By comparison with the bubble shrinking results of real nanoimprinting experiments, it is found that the critical value for obtaining a bubble-free UV nanoimprinting was 3.3% in the oxygen concentration or 15.8% in air percentage.
Sniper forensics
Authors: Greiner Lynn
Published: October 2012

Security attacks and breaches leave clues for investigators who know why they matter.
Health and biomedical informatics
Authors: Weiss Aaron
Published: October 2012

Instant access to authorized electronic medical records promises faster, better, more affordable care.
Personalized medicine
Authors: Rowell Laurie
Published: October 2012

Interrogate the human genome to explore the outcome of any proposed medical intervention.
Privacy in the era of genomics
Authors: Stajano Frank
Published: October 2012

A paranoid's look at advances in DNA research.
Practical approaches to reduce the space requirement of lempel-ziv--based compressed text indices
Authors: Arroyuelo Diego , Navarro Gonzalo
Published: October 2012

Given a text
T
[1¨
n
] over an alphabet of size σ, the
full-text search
problem consists in locating the
occ
occurrences of a given pattern
P
[1¨
m
] in
T
.
Compressed full-text self-indices
are space-efficient representations of the text that provide direct access to and indexed search on it.

The LZ-index of Navarro is a compressed full-text self-index based on the LZ78 compression algorithm. This index requires about 5 times the size of the compressed text (in theory, 4
nH

k

(
T
)+
o
(
n
logσ) bits of space, where
H

k

(
T
) is the
k
-th order empirical entropy of
T
). In practice, the average locating complexity of the LZ-index is
O
(σ
m
log
σ
n
+
occ
σ

m

/2), where
occ
is the number of occurrences of
P
. It can extract text substrings of length ℓ in
O
(ℓ) time. This index outperforms competing schemes both to locate short patterns and to extract text snippets. However, the LZ-index can be up to 4 times larger than the smallest existing indices (which use
nH

k

(
T
)+
o
(
n
logσ) bits in theory), and it does not offer space/time tuning options. This limits its applicability.

In this article, we study practical ways to reduce the space of the LZ-index. We obtain new LZ-index variants that require 2(1+ϵ)
nH

k

(
T
) +
o
(
n
logσ) bits of space, for any 0<ϵ <1. They have an average locating time of
O
(1/ϵ(
m
log
n
+
occ
σ

m
/2

)), while extracting takes
O
(ℓ) time.

We perform extensive experimentation and conclude that our schemes are able to reduce the space of the original LZ-index by a factor of 2/3, that is, around 3 times the compressed text size. Our schemes are able to extract about 1 to 2 MB of the text per second, being twice as fast as the most competitive alternatives. Pattern occurrences are located at a rate of up to 1 to 4 million per second. This constitutes the best space/time trade-off when indices are allowed to use 4 times the size of the compressed text or more.
Redesigning the string hash table, burst trie, and BST to exploit cache
Authors: Askitis Nikolas , Zobel Justin
Published: October 2012

A key decision when developing in-memory computing applications is choice of a mechanism to store and retrieve strings. The most efficient current data structures for this task are the hash table with move-to-front chains and the burst trie, both of which use linked lists as a substructure, and variants of binary search tree. These data structures are computationally efficient, but typical implementations use large numbers of nodes and pointers to manage strings, which is not efficient in use of cache. In this article, we explore two alternatives to the standard representation: the simple expedient of including the string in its node, and, for linked lists, the more drastic step of replacing each list of nodes by a contiguous array of characters. Our experiments show that, for large sets of strings, the improvement is dramatic. For hashing, in the best case the total space overhead is reduced to less than 1 bit per string. For the burst trie, over 300MB of strings can be stored in a total of under 200MB of memory with significantly improved search time. These results, on a variety of data sets, show that cache-friendly variants of fundamental data structures can yield remarkable gains in performance.
Minimizing energy consumptions in wireless sensor networks via two-modal transmission
Authors: Liang Yao , Peng Wei
Published: October 2012

We present a sophisticated framework to systematically explore the temporal correlation in environmental monitoring wireless sensor networks. The presented framework optimizes lossless data compression in communications given the resource constraint of sensor nodes. The insights and analyses obtained from the framework can directly lead to innovative and better design of data gathering protocols for wireless sensor networks operated in noisy environments to dramatically reduce the energy consumptions.
802.11 with multiple antennas for dummies
Authors: Halperin Daniel , Hu Wenjun , Sheth Anmol , Wetherall David
Published: October 2012

The use of multiple antennas and MIMO techniques based on them is the key feature of 802.11n equipment that sets it apart from earlier 802.11a/g equipment. It is responsible for superior performance, reliability and range. In this tutorial, we provide a brief introduction to multiple antenna techniques. We describe the two main classes of those techniques, spatial diversity and spatial multiplexing. To ground our discussion, we explain how they work in 802.11n NICs in practice.
Radio resource management considerations for LTE Femto cells
Authors: Kulkarni Parag , Chin Woon Hau , Farnham Tim
Published: October 2012

Femtocell access points (FAPs), also popularly known as Home Base Stations, are small base stations for use within indoor environments to improve coverage and capacity. FAPs have a limited range (e.g. limited to a home or office area) but offer immense capacity improvements for the network due to the ability to reuse a frequency more often as a result of smaller coverage areas. Because there may be thousands of these devices and since the nature of deployment is adhoc, it may not be possible to carry out elaborate frequency planning like that in the traditional cellular network. This paper aims to outline the radio resource management considerations within the context of femto cells, the broader objective being to initiate a discussion and encourage research in the areas highlighted.
Internet-scale IP alias resolution techniques
Authors: Keys Ken
Published: October 2012

The well-known traceroute probing method discovers links between interfaces on Internet routers. IP alias resolution, the process of identifying IP addresses belonging to the same router, is a critical step in producing Internet topology maps. We compare the performance and accuracy of known alias resolution techniques, propose some enhancements, and suggest a practical combination of techniques that can produce the most accurate and complete IP-to-router mapping at macroscopic scale.
DECOR
Authors: Chen Xu , Mao Yun , Mao Z. Morley , Van der Merwe Jacobus
Published: October 2012

Network management operations are complicated, tedious and error-prone, requiring significant human involvement and expert knowledge. In this paper, we first examine the fundamental components of management operations and argue that the lack of automation is due to a lack of programmability at the right level of abstraction. To address this challenge, we present DECOR, a database-oriented, declarative framework towards automated network management. DECOR models router configuration and any generic network status as relational data in a conceptually centralized database. As such, network management operations can be represented as a series of transactional database queries, which provide the benefit of atomicity, consistency and isolation. The rule-based language in DECOR provides the flexible programmability to specify and enforce network-wide management constraints, and achieve high-level task scheduling. We describe the design rationale and architecture of DECOR and present some preliminary examples applying our approach to common network management tasks.
Building a fast, virtualized data plane with programmable hardware
Authors: Anwer Muhammad Bilal , Feamster Nick
Published: October 2012

Network virtualization allows many networks to share the same underlying physical topology; this technology has offered promise both for experimentation and for hosting multiple networks on a single shared physical infrastructure. Much attention has focused on virtualizing the network control plane, but, ultimately, a limiting factor in the deployment of these virtual networks is data-plane performance: Virtual networks must ultimately forward packets at rates that are comparable to native, hardware-based approaches. Aside from proprietary solutions from vendors, hardware support for virtualized data planes is limited. The advent of open, programmable network hardware promises flexibility, speed, and resource isolation, but, unfortunately, hardware does not naturally lend itself to virtualization. We leverage emerging trends in programmable hardware to design a flexible, hardware-based data plane for virtual networks. We present the design, implementation, and preliminary evaluation of this hardware-based data plane and show how the proposed design can support many virtual networks without compromising performance or isolation.
Understanding data center traffic characteristics
Authors: Benson Theophilus , Anand Ashok , Akella Aditya , Zhang Ming
Published: October 2012

As data centers become more and more central in Internet communications, both research and operations communities have begun to explore how to better design and manage them. In this paper, we present a preliminary empirical study of end-to-end traffic patterns in data center networks that can inform and help evaluate research and operational approaches. We analyze SNMP logs collected at 19 data centers to examine temporal and spatial variations in link loads and losses. We find that while links in the core are heavily utilized the ones closer to the edge observe a greater degree of loss. We then study packet traces collected at a small number of switches in one data center and find evidence of ON-OFF traffic behavior. Finally, we develop a framework that derives ON-OFF traffic parameters for data center traffic sources that best explain the SNMP data collected for the data center. We show that the framework can be used to evaluate data center traffic engineering approaches. We are also applying the framework to design network-level traffic generators for data centers.
VUPoints
Authors: Bao Xuan , Choudhury Romit Roy
Published: October 2012

Mobile phones are becoming a convergent platform for sensing, computation, and communication. This paper envisions VUPoints, a collaborative sensing and video-recording system that takes advantage of this convergence. Ideally, when multiple phones in a social gathering run VUPoints, the output is expected to be a short video-highlights of the occasion, created without human intervention. To achieve this, mobile phones must sense their surroundings and collaboratively detect events that qualify for recording. Short video-clips from different phones can be combined to produce the highlights of the occasion. This paper reports exploratory work towards this longer term project. We present a feasibility study, and show how social events can be sensed through mobile phones and used as triggers for video-recording. While false positives cause inclusion of some uninteresting videos, we believe that further research can significantly improve the efficacy of the system.
OpenRoads
Authors: Yap Kok-Kiong , Kobayashi Masayoshi , Sherwood Rob , Huang Te-Yuan , Chan Michael , Handigol Nikhil , McKeown Nick
Published: October 2012

We present OpenRoads, an open-source platform for innovation in mobile networks. OpenRoads enable researchers to innovate using their own production networks, through providing an wireless extension OpenFlow. Therefore, you can think of OpenRoads as "OpenFlow Wireless".

The OpenRoads' architecture consists of three layers: flow, slicing and controller. These layers provide flexible control, virtualization and high-level abstraction. This allows researchers to implement wildly different algorithms and run them concurrently in one network. OpenRoads also incorporates multiple wireless technologies, specifically WiFi and WiMAX. We have deployed OpenRoads, and used it as our production network. Our goal here is for those to deploy OpenRoads and build their own experiments on it.
Reconnecting the internet with ariba
Authors: Hübsch Christian , Mayer Christoph P. , Mies Sebastian , Bless Roland , Waldhorst Oliver P. , Zitterbart Martina
Published: October 2012

End-to-End connectivity in today's Internet can no longer be taken for granted. Middleboxes, mobility, and protocol heterogeneity complicate application development and often result in application-specific solutions. In our demo we present ariba: an overlay-based approach to handle such network challenges and to provide consistent homogeneous network primitives in order to ease application and service development.
Performance and strain levels of it workers engaged in rapidly changing environments
Authors: Chilton Michael A. , Hardgrave Bill C. , Armstrong Deborah J.
Published: October 2012

Technological changes ripple through information technology (IT) development environments. IT professionals must often incorporate these changes into their job or risk obsolescence. This paper looks at the effects of technological change, and focuses on job environment conditions which affect individual performance, health, and well-being by applying person-job fit theory to software developers that have moved to an object-oriented development approach. Heretofore, the literature on person-job fit has viewed its effects statically, disregarding the effects of change. The current research recognizes the dynamics of the IT workplace and investigates the impact of a rapidly changing job environment on individual IT workers by including a comparison of fit at two different points in time. Results indicate that for a change in job environment, individuals whose professional needs match what is supplied by the job fare better in terms of strain and performance. By devoting attention to supplying IT workers who are facing increasing amounts of change with job environment dimensions these workers need, managers are able to direct their efforts toward the job environment dimensions that may improve worker performance and reduce the ill-effects of stress and strain. This, in turn, may have positive effects on overall system development. This study provides insights for managers regarding the pressures felt by software developers moving to a new development environment, and contributes to the person-job fit literature by incorporating a technological change in job environment.
The impact of IS-marketing alignment on marketing performance and business performance
Authors: Hooper Val A. , Huff Sid L. , Thirkell Peter C.
Published: October 2012

The importance of the alignment between information systems (IS) and the business has been emphasized for over a decade. To date, no empirical study has explored the impact of the alignment of IS and marketing, despite initial indications that such an alignment could impact favorably upon business performance. This study reports on a new conceptualization of alignment, together with the development and testing of a parsimonious model which addresses this issue. Data from a survey of 415 respondents from medium-large New Zealand companies were used to test the model. It was found that IS-marketing alignment had a positive impact on both business performance and marketing performance, and that marketing performance in turn had a modest but positive impact on business performance.
Open innovation in secondary software firms
Authors: Morgan Lorraine , Finnegan Patrick
Published: October 2012

Open source software (OSS) is probably the best known exemplar of open innovation, with many practitioner-oriented publications having debated the merits and drawbacks of OSS in recent years. Nevertheless, much of the academic research on OSS has focused on individual rather than organizational issues. Hence while there is some understanding of why individual developers and users opt for particular OSS applications, relatively little is known about the adoption of OSS as a software acquisition policy. This paper presents a study of 13 managers in the secondary software sector in Europe, and examines how their perceptions of the benefits and drawbacks of OSS affected their decision to adopt an open source policy for software in their companies. The study reveals how their perceptions of the business and technical benefits and drawbacks of OSS influenced the technological, organizational, environmental and individual factors considered within the adoption process. The findings reveal that many of these factors are similar to those reported by previous work on the adoption of innovation, leading us to conclude that organizational processes for the adoption of open innovation are reliant on the practices for closed innovation despite frequently cited loss of organizational control associated with open innovation.
Eating our own dog food
Authors: Cordy James R.
Published: October 2012

Languages and systems to support generative and transformational solutions have been around a long time. Systems such as XVCL, DMS, ASF+SDF, Stratego and TXL have proven mature, efficient and effective in a wide range of applications. Even so, adoption remains a serious issue - almost all successful production applications of these systems in practice either involve help from the original authors or years of experience to get rolling. While work on accessibility is active, with efforts such as ETXL, Stratego XT, Rascal and Colm, the fundamental big step remains - it's not obvious how to apply a general purpose transformational system to any given generation or transformation problem, and the real power is in the paradigms of use, not the languages themselves.

In this talk I will propose an agenda for addressing this problem by taking our own advice - designing and implementing domain specific languages (DSLs) for specific generative, transformational and analysis problem domains. We widely advise end users of the need for DSLs for their kinds of problems - why not for our kinds? And we use our tools for implementing their DSLs - why not our own? I will outline a general method for using transformational techniques to implement transformational and generative DSLs, and review applications of the method to implementing example text-based DSLs for model-based code generation and static code analysis. Finally, I will outline some first steps in implementing model transformation DSLs using the same idea - retaining the maturity and efficiency of our existing tools while bringing them to the masses by "eating our own dogfood".
Reusable, generic program analyses and transformations
Authors: Willcock Jeremiah James , Lumsdaine Andrew , Quinlan Daniel J.
Published: October 2012

The optimizations in modern compilers are constructed for a predetermined set of primitive types. As a result, programmers are unable to exploit optimizations for user-defined types where these optimizations would be correct and beneficial. Moreover, because the set of optimizations is also fixed, programmers are unable to incorporate new optimizations into the compiler. To address these limitations, we apply the reuse methodologies from generic programming to compiler analyses and optimizations. To enable compilers to apply optimizations to classes of types rather than particular types, we define optimizations in terms of generic interface descriptions (similar to C++ concepts or Haskell type classes). By extending these interface descriptions to include associated program analysis and transformation fragments, we enable compilers to incorporate user-defined transformations and analyses. Since these transformations are explicitly associated with interface descriptions, they can be applied in generic fashion by the compiler. We demonstrate that classical compiler optimizations, when generalized using this framework, can apply to a broad range of types, both built-in and user-defined. Finally, we present an initial implementation, the principles of which are generalizable to other compilers.
Toward foundations for type-reflective metaprogramming
Authors: Garcia Ronald , Lumsdaine Andrew
Published: October 2012

C++ template metaprogramming has been used with great success to build software applications and libraries. In practice, however, template metaprogramming suffers usability, reliability, and capability shortcomings, and it is not well understood in theory. Template metaprogramming has these problems because it relies on emergent properties of disparate language features that were tailored to other purposes. As a step toward solid and sound language support for metaprogramming, this paper establishes firm semantic foundations for select capabilities of template metaprogramming.

We analyze C++ and the idioms of template metaprogramming and isolate, in a language-neutral fashion, fundamental capabilities of C++ that enable metaprogramming. Guided by this analysis, we present a design for a core calculus that directly expresses fundamental metaprogramming capabilities, including static computation, code generation, and type reflection. We prove a typesafety property for compile-time evaluation of metaprograms. To formally connect the core calculus to programming practice, we present a more convenient surface language for metaprogramming. Its semantics are captured by type-directed translation to the core calculus. We prove that this translation preserves well-typing.

This idealized presentation averts some of the shortcomings of C++ template metaprogramming and provides a framework for further study.
Extending AspectJ for separating regions
Authors: Akai Shumpei , Chiba Shigeru
Published: October 2012

Synchronization is a good candidate for an aspect in aspect-oriented programming (AOP) since programmers have to choose the best granularity of synchronization for the underlying hardware to obtain the best execution performance. If synchronization is an aspect, programmers can change the synchronization code independently of the rest of the program when the program runs on different hardware. However, existing AOP languages such as AspectJ have problems. They cannot select an arbitrary code region as a join point. Moreover, they cannot enforce weaving of a synchronization aspect. Since it is an alternative feature in feature modeling, at least one of available synchronization aspects must be woven. Otherwise, the program would be thread-unsafe. Since an aspect in AspectJ is inherently optional, programmers must be responsible for weaving it. To solve these problems, this paper proposes two new constructs for AspectJ,
regioncut
and
assertions for advice
. Regioncut selects arbitrary code region as a join point and assertion for advice enforces weaving a mandatory advice. We implemented these constructs by extending the AspectBench compiler. We evaluated the design of our constructs by applying them to two open-source software products, Javassist and Hadoop.
A language and framework for invariant-driven transformations
Authors: Liu Yanhong A. , Gorbovitski Michael , Stoller Scott D.
Published: October 2012

This paper describes a language and framework that allow coordinated transformations driven by invariants to be specified declaratively, as invariant rules, and applied automatically. The framework supports incremental maintenance of invariants for program design and optimization, as well as general transformations for instrumentation, refactoring, and other purposes. This paper also describes our implementations for transforming Python and C programs and experiments with successful applications of the systems in generating efficient implementations from clear and modular specifications, in instrumenting programs for runtime verification, profiling, and debugging, and in code refactoring.
JavaGI in the battlefield
Authors: Wehr Stefan , Thiemann Peter
Published: October 2012

Generalized interfaces are an extension of the interface concept found in object-oriented languages such as Java or C#. The extension is inspired by Haskell's type classes. It supports retroactive and type-conditional interface implementations, binary methods, symmetric multimethods, interfaces over families of types, and static interface methods.

This article reports practical experience with generalized interfaces as implemented in the JavaGI language. Several real-world case studies demonstrate how generalized interfaces provide solutions to extension and integration problems with components in binary form, how they make certain design patterns redundant, and how they eliminate various run-time errors. In each case study, the use of JavaGI results in elegant and highly readable code.

Furthermore, the article discusses the implementation of a compiler and a run-time system for JavaGI. Benchmarks show that our implementation offers acceptable performance.
Advanced runtime adaptation for Java
Authors: Villazón Alex , Binder Walter , Ansaloni Danilo , Moret Philippe
Published: October 2012

Dynamic aspect-oriented programming (AOP) enables runtime adaptation of aspects, which is important for building sophisticated, aspect-based software engineering tools, such as adaptive profilers or debuggers that dynamically modify instrumentation code in response to user interactions. Today, many AOP frameworks for Java, notably AspectJ, focus on aspect weaving at compile-time or at load-time, and offer only limited support for aspect adaptation and reweaving at runtime. In this paper, we introduce HotWave, an AOP framework based on AspectJ for standard Java Virtual Machines (JVMs). HotWave supports dynamic (re)weaving of previously loaded classes, and it ensures that all classes loaded in a JVM can be (re)woven, including the classes of the standard Java class library. HotWave features a novel mechanism for inter-advice communication, enabling efficient data passing between advices that are woven into the same method. We explain HotWave's programming model and discuss our implementation techniques. As case study, we present an adaptive, aspect-based profiler that leverages HotWave's distinguishing features.
HotWave
Authors: Villazón Alex , Binder Walter , Ansaloni Danilo , Moret Philippe
Published: October 2012

Developing tools for profiling, debugging, testing, and reverse engineering is error-prone, time-consuming, and therefore costly when using low-level techniques, such as bytecode instrumentation. As a solution to these problems, we promote tool development in Java using high-level aspect-oriented programming (AOP). We demonstrate that the use of aspects yields compact tools that are easy to develop and extend. As enabling technology, we rely on HotWave, a new tool for dynamic and comprehensive aspect weaving. HotWave reconciles compatibility with existing virtual machine and AOP technologies. It provides support for runtime adaptation of aspects and reweaving of previously loaded code, as well as the ability to weave aspects into all methods executing in a Java Virtual Machine, including methods in the standard Java class library. HotWave also features a new mechanism for efficiently passing data between advices that are woven into the same method. We demonstrate the benefits of HotWave's distinguishing features with two case studies in the area of profiling.
Abstract parsing for two-staged languages with concatenation
Authors: Kong Soonho , Choi Wontae , Yi Kwangkeun
Published: October 2012

This article, based on Doh, Kim, and Schmidt's "abstract parsing" technique, presents an abstract interpretation for statically checking the syntax of generated code in two-staged programs. Abstract parsing is a static analysis technique for checking the syntax of generated strings. We adopt this technique for two-staged programming languages and formulate it in the abstract interpretation framework. We parameterize our analysis with the abstract domain so that one can choose the abstract domain as long as it satisfies the condition we provide. We also present an instance of the abstract domain, namely an abstract parse stack and its widening with k-cutting.
Synthesis of fast programs for maximum segment sum problems
Authors: Nedunuri Srinivas , Cook William R.
Published: October 2012

It is well-known that a naive algorithm can often be turned into an efficient program by applying appropriate semantics-preserving transformations. This technique has been used to derive programs to solve a variety of maximum-sum programs. One problem with this approach is that each problem variation requires a new set of transformations to be derived. An alternative approach to generation combines problem specifications with flexible algorithm theories to derive efficient algorithms. We show how this approach can be implemented in Haskell and applied to solve constraint satisfaction problems. We illustrate this technique by deriving programs for three varieties of maximum-weightsum problem. The derivations of the different programs are similar, and the resulting programs are asymptotically faster in practice than the programs created by transformation.
A generative programming approach to developing pervasive computing systems
Authors: Cassou Damien , Bertran Benjamin , Loriant Nicolas , Consel Charles
Published: October 2012

Developing pervasive computing applications is a difficult task because it requires to deal with a wide range of issues: heterogeneous devices, entity distribution, entity coordination, low-level hardware knowledge. . . Besides requiring various areas of expertise, programming such applications involves writing a lot of administrative code to glue technologies together and to interface with both hardware and software components.

This paper proposes a generative programming approach to providing programming, execution and simulation support dedicated to the pervasive computing domain. This approach relies on a domain-specific language, named DiaSpec, dedicated to the description of pervasive computing systems. Our generative approach factors out features of distributed systems technologies, making DiaSpec-specified software systems portable.

The DiaSpec compiler is implemented and has been used to generate dedicated programming frameworks for a variety of pervasive computing applications, including detailed ones to manage the building of an engineering school.
Algorithms for user interfaces
Authors: Järvi Jaakko , Marcus Mat , Parent Sean , Freeman John , Smith Jacob
Published: October 2012

User interfaces for modern applications must support a rich set of interactive features. It is commonplace to find applications with dependencies between values manipulated by user interface elements, conditionally enabled controls, and script record-ability and playback against different documents. A significant fraction of the application programming effort is devoted to implementing such functionality, and the resulting code is typically not reusable.

This paper extends our "property models" approach to programming user interfaces. Property models allow a large part of the functionality of a user interface to be implemented in reusable libraries, reducing application specific code to a set of declarative rules. We describe how, as a by-product of computations that maintain the values of user interface elements, property models obtain accurate information of the currently active dependencies among those elements. This information enables further expanding the class of user interface functionality that we can encode as generic algorithms. In particular, we describe automating the decisions for the enablement of user interface widgets and activation of command widgets. Failing to disable or deactivate widgets correctly is a common source of user-interface defects, which our approach largely removes.

We report on the increased reuse, reduced defect rates, and improved user interface design turnarounds in a commercial software development effort as a result of adopting our approach.
A model of refactoring physically and virtually separated features
Authors: Kästner Christian , Apel Sven , Kuhlemann Martin
Published: October 2012

Physical separation with class refinements and method refinements à la AHEAD and virtual separation using annotations à la
#ifdef
or CIDE are two competing implementation approaches for software product lines with complementary advantages. Although both approaches have been mainly discussed in isolation, we strive for an integration to leverage the respective advantages. In this paper, we lay the foundation for such an integration by providing a model that supports both physical and virtual separation and by describing refactorings in both directions. We prove the refactorings complete, so every virtually separated product line can be automatically transformed into a physically separated one (replacing annotations by refinements) and vice versa. To demonstrate the feasibility of our approach, we have implemented the refactorings in our tool CIDE and conducted four case studies.
Mapping problem-space to solution-space features
Authors: Sanen Frans , Truyen Eddy , Joosen Wouter
Published: October 2012

Mapping problem-space features into solution-space features is a fundamental configuration problem in software product line engineering. A configuration problem is defined as generating the most optimal combination of software features given a requirements specification and given a set of configuration rules. Current approaches however provide little support for expressing complex configuration rules between problem and solution space that support incomplete requirements specifications. In this paper, we propose an approach to model complex configuration rules based on a generalization of the concept of problem-solution feature interactions. These are interactions between solution-space features that only arise in specific problem contexts. The use of an existing tool to support our approach is also discussed: we use the DLV answer set solver to express a particular configuration problem as a logic program whose answer set corresponds to the optimal combinations of solution-space features. We motivate and illustrate our approach with a case study in the field of managing dynamic adaptations in distributed software, where the goal is to generate an optimal protocol for accommodating a given adaptation.
Exascale computing
Authors: Agerwala Tilak
Published: October 2012

Supercomputing systems have made great strides in recent years as the extensive computing needs of cutting-edge engineering work and scientific discovery have driven the development of more powerful systems. In 2008, the first petaflop machine was released, and historic trends indicate that in ten years, we should be at the exascale level. Indeed, various agencies are targeting a computer system capable of 1 Exaop (10**18 ops) of computation within the next decade. We believe that applications in many industries will be materially transformed by exascale computers.

Meeting the exascale challenge will require significant innovation in technology, architecture and programmability. Power is a fundamental problem at all levels; traditional memory cost and performance are not keeping pace with compute potential; the storage hierarchy will have to be re-architected; networks will be a much bigger part of the system cost; reliability at exascale levels will require a holistic approach to architecture design, and programmability and ease-of-use will be an essential component to extract the promised performance at the exascale level.

In this talk, I will discuss the importance of exascale computing and address the major challenges, touching on the areas of technology, architecture, reliability and usability.
Structure-driven optimizations for amorphous data-parallel programs
Authors: Méndez-Lojo Mario , Nguyen Donald , Prountzos Dimitrios , Sui Xin , Hassaan M. Amber , Kulkarni Milind , Burtscher Martin , Pingali Keshav
Published: October 2012

Irregular algorithms are organized around pointer-based data structures such as graphs and trees, and they are ubiquitous in applications. Recent work by the Galois project has provided a systematic approach for parallelizing irregular applications based on the idea of optimistic or speculative execution of programs. However, the overhead of optimistic parallel execution can be substantial. In this paper, we show that many irregular algorithms have structure that can be exploited and present three key optimizations that take advantage of algorithmic structure to reduce speculative overheads. We describe the implementation of these optimizations in the Galois system and present experimental results to demonstrate their benefits. To the best of our knowledge, this is the first system to exploit algorithmic structure to optimize the execution of irregular programs.
Is transactional programming actually easier?
Authors: Rossbach Christopher J. , Hofmann Owen S. , Witchel Emmett
Published: October 2012

Chip multi-processors (CMPs) have become ubiquitous, while tools that ease concurrent programming have not. The promise of increased performance for all applications through ever more parallel hardware requires good tools for concurrent programming, especially for average programmers. Transactional memory (TM) has enjoyed recent interest as a tool that can help programmers program concurrently.

The transactional memory (TM) research community is heavily invested in the claim that programming with transactional memory is easier than alternatives (like locks), but evidence for or against the veracity of this claim is scant. In this paper, we describe a user-study in which 237 undergraduate students in an operating systems course implement the same programs using coarse and fine-grain locks, monitors, and transactions. We surveyed the students after the assignment, and examined their code to determine the types and frequency of programming errors for each synchronization technique. Inexperienced programmers found baroque syntax a barrier to entry for transactional programming. On average, subjective evaluation showed that students found transactions harder to use than coarse-grain locks, but slightly easier to use than fine-grained locks. Detailed examination of synchronization errors in the students' code tells a rather different story. Overwhelmingly, the number and types of programming errors the students made was much lower for transactions than for locks. On a similar programming problem, over 70% of students made errors with fine-grained locking, while less than 10% made errors with transactions.
Debugging programs that use atomic blocks and transactional memory
Authors: Zyulkyarov Ferad , Harris Tim , Unsal Osman S. , Cristal Adrían , Valero Mateo
Published: October 2012

With the emergence of research prototypes, programming using atomic blocks and transactional memory (TM) is becoming more attractive. This paper describes our experience building and using a debugger for programs written with these abstractions. We introduce three approaches: (
i
) debugging at the level of atomic blocks, where the programmer is shielded from implementation details (such as exactly what kind of TM is used, or indeed whether lock inference is used instead), (
ii
) debugging at the level of transactions, where conflict rates, read sets, write sets, and other TM internals are visible, and (
iii
) debug-time transactions, which let the programmer manipulate synchronization from within the debugger - e.g., enlarging the scope of an atomic block to try to identify a bug.

In this paper we explain the rationale behind the new debugging approaches that we propose. We describe the design and implementation of an extension to the WinDbg debugger, enabling support for C# programs using atomic blocks and TM. We also demonstrate the design of a "conflict point discovery" technique for identifying program statements that introduce contention between transactions. We illustrate how these techniques can be used by optimizing a C# version of the Genome application from STAMP TM benchmark suite.
Scheduling support for transactional memory contention management
Authors: Maldonado Walther , Marlier Patrick , Felber Pascal , Suissa Adi , Hendler Danny , Fedorova Alexandra , Lawall Julia L. , Muller Gilles
Published: October 2012

Transactional Memory (TM) is considered as one of the most promising paradigms for developing concurrent applications. TM has been shown to scale well on >multiple cores when the data access pattern behaves "well," i.e., when few conflicts are induced. In contrast, data patterns with frequent write sharing, with long transactions, or when many threads contend for a smaller number of cores, result in numerous conflicts. Until recently, TM implementations had little control of transactional threads, which remained under the supervision of the kernel's transaction-ignorant scheduler. Conflicts are thus traditionally resolved by consulting an STM-level
contention manager
. Consequently, the contention managers of these "conventional" TM implementations suffer from a lack of precision and often fail to ensure reasonable performance in high-contention workloads.

Recently, scheduling-based TM contention-management has been proposed for increasing TM efficiency under high-contention [2, 5, 19]. However, only user-level schedulers have been considered. In this work, we propose, implement and evaluate several novel kernel-level scheduling support mechanisms for TM contention management. We also investigate different strategies for efficient communication between the kernel and the user-level TM library. To the best of our knowledge, our work is the first to investigate kernel-level support for TM contention management.

We have introduced kernel-level TM scheduling support into both the Linux and Solaris kernels. Our experimental evaluation demonstrates that lightweight kernel-level scheduling support significantly reduces the number of aborts while improving transaction throughput on various workloads.