bluuebunny/crossref_metadata_2025 huggingface dataset:
PBPAIR
Authors: Kim Minyoung , Oh Hyunok , Dutt Nikil , Nicolau Alex , Venkatasubramanian Nalini
Published: January 2007

Error resilient encoding in video communication is becoming increasingly important due to data transmission over unreliable channels. In this paper, we propose a new power-aware error resilient coding scheme based on network error probability and user expectation in video communication using mobile handheld devices. By considering both image content and network conditions, we can achieve a fast recoverable and energy-efficient error resilient coding scheme. More importantly, our approach allows system designers to evaluate various operating points in terms of error resilient level and energy consumption over a wide range of system operating conditions. We have implemented our scheme on an H.263 video codec algorithm, compared it with the previous AIR, GOP and PGOP coding schemes, and measured energy consumption and video quality on the IPAQ and Zaurus PDAs. Our experimental results show that our approach reduces energy consumption by 34%, 24% and 17% compared with AIR, GOP and PGOP schemes respectively, while incurring only a small fluctuation in the compressed frame size. In addition, our experimental results prove that our approach allows faster error recovery than the previous AIR, GOP and PGOP approaches. We believe our error resilient coding scheme is therefore eminently applicable for video communication on energy-constrained wireless mobile handheld devices.
Dynamic polymorphism in Fortran 95
Authors: Bader Reinhold
Published: January 2007

This article discusses the implementation of generic list or tree structures in Fortran 95 via emulation of dynamic polymorphism. The method allows the unified handling of multiple kinds of information structures [1] using a single intermediate module. It is shown that a well-designed implementation additionally requires the use of the submodule feature as described in the Technical Report ISO/IEC 19767.
Generating k-best solutions to auction winner determination problems
Authors: Kelly Terence , Byde Andrew
Published: January 2007

Auction participants cannot always articulate their requirements and preferences. Sometimes, for instance, the buyer in a procurement auction cannot quantify the value of non-price solution attributes or delineate between hard and soft constraints. This precludes formulating the winner determination problem (WDP) as an optimization problem. Existing decision-support aids for such situations extend an optimization framework. We present an approach that frames the decision problem as one of exploration rather than optimization. Our method relies on an algorithm that generates
k
-best solutions to auction WDPs. Our algorithm can incorporate hard constraints into the generation process and can scale to practical procurement auctions. We show how to extract useful guidance from
k
-best WDP solutions, and we evaluate our method using real bids submitted by real suppliers in an HP material parts procurement auction.
Personal reflections on APL96
Authors: Jones Curtis A.
Published: January 2007

APL96 was a fine conference. The folks in Lancaster are friendly and helpful. Well, Lancaster Castle has served, and still serves, as a prison. In 1660 one of the prisoners was George Fox, whose objections to the Church of England not only landed him in the castle but started the Quakers. His reputation has improved, and the conference was mostly held in a building named after him.
Building C# COM DLLs for APL
Authors: Askoolum Ajay
Published: January 2007

In this article, I present a visual guide to building and deploying a C# COM (Component Object Model) Interrop DLL (Dynamic Link Library) for APL using Visual C# 2005 Express Edition. This is not a tutorial on either C# or on Visual C# 2005 Express Edition, but simply an illustration of the process for building and COM DLL in C#.
The importance of percent-done progress indicators for computer-human interfaces
Authors: Myers Brad A.
Published: January 2007

A “percent-done progress indicator” is a graphical technique which allows the user to monitor the progress through the processing of a task. Progress indicators can be displayed on almost all types of output devices, and can be used with many different kinds of programs. Practical experience and formal experiments show that prograss indicators are an important and useful user-interface tool, and that they enhance the attractiveness and effectiveness of programs that incorporate them. This paper discusses why progress indicators are important. It includes the results of a formal experiment with progress indicators. One part of the experiment demonstrates that people prefer to have progress indicators. Another part attempted to replicate earlier findings to show that people prefer constant to variable response time in general, and then to show that this effect is reversed with progress indicators, but the results were not statistically significant. In fact, no significant preference for constant response time was shown, contrary to previously published results.
Selection from alphabetic and numeric menu trees using a touch screen
Authors: Landauer T. K. , Nachbar D. W.
Published: January 2007

Goal items were selected by a series of touch-menu choices among sequentially subdivided ranges of integers or alphabetically ordered words. The number of alternatives at each step,
b
, was varied, and, inversely, the size of the target area for the touch. Mean response time for each screen was well described by
T
=
k
+
c
log
b
, in agreement with the Hick-Hyman and Fitts' laws for decision and movement components in series. It is shown that this function favors breadth over depth in menus, whereas others might not. Speculations are offered as to when various functions could be expected.
Designing a menu-based interface to an operating system
Authors: Tullis Thomas S.
Published: January 2007

The development of a large menu-based interface to an operating system posed a number of interesting user interface questions. Among those were how to determine the user's view of the relationships among the myriad of functions in the system, and how to reflect those relationships in a menu hierarchy. An experiment utilizing a sorting technique and hierarchical cluster analysis was quite effective in learning the user's perception of the relationships among the system functions. A second experiment comparing a “broad” menu hierarchy to a “deep” menu hierarchy showed that users made significantly fewer inappropriate menu selections with the broad hierarchy.
Connecting theory and practice
Authors: Butler Keith A.
Published: January 2007

This paper describes a case study of the Human Factors design, development, and testing of a computer-based financial analysis package. The project applied the “usability goals” method proposed by Bennett (1984) to structure the definition, design, and testing of the new system. Learnability was defined as a key attribute in the product concept because of its salience in users' perception of system quality. The learnability attribute was assigned an operational definition in terms of time to mastery and error avoidance/recovery. The “back-to-front” strategy of Didner & Butler (1982) was applied for designing the menus. Empirical testing of user performance on sample problems in the alpha stage indicated that the new system surpassed the learnability objective. Lessons learned from this case study concern leverage in getting better managerial attention for Human Factors considerations in development projects, and clearer structure to direct needed research.
Evaluating the user interface
Authors: Lund Michelle A.
Published: January 2007

In the development of a new interactive graphics application, considerable effort was spent on designing a user interface which would be easy to use. When a portion of the application was completed, typical potential users were brought in to help evaluate the interface. They were given a sample task and a short introduction to the application; then their efforts to complete the task were observed and videotaped.

This method of evaluating the user interface provided the development staff with quite a bit of valuable information. Changes were made, and more testing was done, including using some subjects for a second time.

This paper describes how this evaluation method was used for two purposes: to point out problem areas in the interface, and to verify that changes made have improved the user interface.
Prompting, feedback and error correction in the design of a scenario machine
Authors: Carroll John M. , Kay Dana S.
Published: January 2007

The recent technical literature abounds with a variety of studies documenting and analyzing the problems people encounter in learning to use contemporary computer equipment. This has been a major focus of the recent work in our laboratory ([6], [9]). The project such work must entrain is the development of design approaches to these problems. We have been and are developing alternate designs for training manuals and for in-system training ([2], [4], [5], [7]).

This paper is a report of work in progress in this area. We describe a design approach to in-system training referred to as the Scenario Machine, and describe some initial results from an empirical learning study of four scenario machines.
Microcomputer user interface toolkits (panel session)
Authors: Buxton William A. S. , Reed David R. , Tesler Larry , MacGregor Scott
Published: January 2007

A well-designed user interface is a
very
valuable asset: the best available today are based on hundreds of man-years of work combining results of research in human factors, tasteful design reviewed and modified through extensive end-user testing, and many rounds of implementation effort. As a result, the user interface “toolkit” is emerging as the hottest new software item. A toolkit can provide software developers with a programming environment in which the user interface coding is already done so that new applications programs can automatically be integrated with other workstation functions.

The panel will evaluate this new trend. Tesler and MacGregor, will present the designs of the leading toolkit products from Apple and Microsoft, respectively. Reed will analyze the choices from the point of view of the third party software vendors' requirements. Noting that the effort going into these products may well result in
de facto
standard setting, Buxton will question the appropriateness of making this commitment based on microcomputer hardware.
Event-response systems
Authors: Hill Ralph D.
Published: January 2007

Event-Response Systems are a technique for specifying the syntax of multi-threaded dialogues. They are based on the paradigm of specifying system responses to events generated by the user. They can compactly represent the concurrency needed to implement multi-threaded dialogues. This concurrency support also allows interfaces to be structured differently than is possible with existing dialogue specification systems based on state transition specifications or grammars. This flexibility allows many interfaces, especially direct manipulation interfaces, to be specified with a more modular structure than most existing systems allow.

Event-Response Systems are described formally, and a dialogue specification language based on the ERS formalism is informally presented. Some example uses and implementation techniques are also described.
A comparison of rule-based and positionally constant arrangements of computer menu items
Authors: Somberg Benjamin L.
Published: January 2007

An experiment was conducted to evaluate user performance under four different menu item arrangements: alphabetic, probability of selection (most popular choices are positioned near the beginning of the list), random, and positionally constant (consistent assignment of individual items to screen positions). During the initial stages of practice, the rule-based approaches produced faster mean search times, but after moderate amounts of practice, the positionally constant arrangement appeared to be most efficient. People seem to remember quite easily the location of items on a display, indicating that positional constancy can be an important factor in increasing the efficiency of the search of computer menus and other displays.
A control panel interface for graphics and image processing applications
Authors: Fisher Gene L. , Joy Kenneth I.
Published: January 2007

This paper describes a graphical interface for application programs. The interface is based on the notion of a
control panel
. A control panel contains a browsable list of an application's parameters and a set of functions to control the application's execution. A variety of graphical knobs and gauges may be associated with any or all of the parameters to permit fine-grain execution control, including animation of an application's output. The control panel interface is integrated into the framework of an interactive programming environment for graphics and image processing applications. This integration is an important feature of the overall interface design.
Notecards in a nutshell
Authors: Halasz Frank G. , Moran Thomas P. , Trigg Randall H.
Published: January 2007

NoteCards is an extensible environment designed to help people formulate, structure, compare, and manage ideas. NoteCards provides the user with a “semantic network” of electronic notecards interconnected by typed links. The system provides tools to organize, manage, and display the structure of the network, as well as a set of methods and protocols for creating programs to manipulate the information in the network. NoteCards is currently being used by more than 50 people engaged in idea processing tasks ranging from writing research papers through designing parts for photocopiers.

In this paper we briefly describe NoteCards and the conceptualization of idea processing tasks that underlies its design. We then describe the NoteCards user community and several prototypical NoteCards applications. Finally, we discuss what we have learned about the system's strengths and weaknesses from our observations of the NoteCards user community.
The definition, editing, and contouring of surfaces for the analysis of field problems
Authors: Dickinson Robert R. , Bartels Richard H.
Published: January 2007

This paper reports on an interactive system for manipulating a tensor-product B-spline approximation to field data for applications in which contours are of interest. The features of the system are: an interpolation technique for approximating fields defined from scattered or gridded data by tensor-product B-splines, an interactive display providing control-vertex manipulation of the resulting B-spline approximation, and a contouring algorithm that is designed specifically for B-spline surfaces.
J&
Authors: Nystrom Nathaniel , Qi Xin , Myers Andrew C.
Published: January 2007

This paper introduces a programming language that makes it convenient to compose large software systems, combining their features in a modular way. J& supports
nested intersection
, building on earlier work on nested inheritance in the language Jx. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection enables composition and extension of
two or more
packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.
Statically scoped object adaptation with expanders
Authors: Warth Alessandro , Stanojević Milan , Millstein Todd
Published: January 2007

This paper introduces the
expander
, a new object-oriented (OO) programming language construct designed to support object adaptation. Expanders allow existing classes to be noninvasively updated with new methods, fields, and superinterfaces. Each client can customize its view of a class by explicitly importing any number of expanders. This view then applies to all instances of that class, including objects passed to the client from other components. A form of
expander overriding
allows expanders to interact naturally with OO-style inheritance.We describe the design, implementation, and evaluation of eJava, an extension to Java supporting expanders. We illustrate eJava's syntax and semantics through several examples. The statically scoped nature of expander usage allows for a modular static type system that prevents several important classes of errors. We describe this modular static type system informally, formalize eJava and its type system in an extension to Featherweight Java, and prove a type soundness theorem for the formalization. We also describe a modular compilation strategy for eJava, which we have implemented using the Polyglot extensible compiler framework. Finally, we illustrate the practical benefits of eJava by using this compiler in two experiments.
JTL
Authors: Cohen Tal , Gil Joseph (Yossi) , Maman Itay
Published: January 2007

We present an overview of JTL (the Java Tools Language, pronounced "Gee-tel"), a novel language for querying JAVA [8] programs. JTL was designed to serve the development of source code software tools for JAVA, and as a small language which to aid programming language extensions to JAVA. Applications include definition of pointcuts for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, definition of micro-patterns, etc. We argue that the JTL expression of each of these is systematic, concise, intuitive and general.JTL relies on a simply-typed relational database for program representation, rather than an abstract syntax tree. The underlying semantics of the language is restricted to queries formulated in First Order Predicate Logic augmented with transitive closure (FOPL).Special effort was taken to ensure terse, yet readable expression of logical conditions. The JTL pattern public abstract class, for example, matches all abstract classes which are publicly accessible, while class (public clone();) matches all classes in which method
clone
is public. To this end, JTL relies on a DATALOG-like syntax and semantics, enriched with quantifiers and pattern matching which all but entirely eliminate the need for recursive calls.JTL's query analyzer gives special attention to the fragility of the "closed world assumption" in examining JAVA software, and determines whether a query relies on such an assumption.The performance of the JTL interpreter is comparable to that of JQuery after it generated its database cache, and at least an order of magnitude faster when the cache has to be rebuilt.
Uniform proxies for Java
Authors: Eugster Patrick
Published: January 2007

The proxy abstraction has a longlasting tradition in object settings. From design pattern to inherent language support, from remote method invocations to simple forms of behavioral reflection - incarnations as well as applications of proxies are innumerable.Since version 1.3, Java supports the concept of
dynamic
proxy. Such an object conforms to a set of types specified by the program and can be used wherever an expression of any of these types is expected, yet reifies invocations performed on it. Dynamic proxies have been applied to implement paradigms as diverse as behavioral reflection, structural conformance, or multi-methods. Alas, these proxies are only available "for interfaces". The case of creating dynamic proxies for a set of types including a class type has not been considered, meaning that it is currently not possible to create a dynamic proxy mimicking an instance of a given class. This weakness strongly limits any application of dynamic proxies.In this paper we unfold the current support for dynamic proxies in Java, assessing it in the light of a set of generic criteria for proxy implementations. We present an approach to supporting dynamic proxies "for classes" in Java, consisting in transformations performed on classes at load-time, including a generic scheme for enforcing encapsulation upon field accesses. These transformations seemlessly extend the scope of the current support for dynamic proxies. We discuss the precise benefits and costs of our extension in terms of the criteria introduced, and illustrate the usefulness of uniformly available proxies by implementing future method invocations both safely and transparently.
The DaCapo benchmarks
Authors: Blackburn Stephen M. , Garner Robin , Hoffmann Chris , Khang Asjad M. , McKinley Kathryn S. , Bentzur Rotem , Diwan Amer , Feinberg Daniel , Frampton Daniel , Guyer Samuel Z. , Hirzel Martin , Hosking Antony , Jump Maria , Lee Han , Moss J. Eliot B. , Phansalkar Aashish , Stefanović Darko , VanDrunen Thomas , von Dincklage Daniel , Wiedermann Ben
Published: January 2007

Since benchmarks drive computer science research and industry product development, which ones we use and how we evaluate them are key questions for the community. Despite complex runtime tradeoffs due to dynamic compilation and garbage collection required for Java programs, many evaluations still use methodologies developed for C, C++, and Fortran. SPEC, the dominant purveyor of benchmarks, compounded this problem by institutionalizing these methodologies for their Java benchmark suite. This paper recommends benchmarking selection and evaluation methodologies, and introduces the DaCapo benchmarks, a set of open source, client-side Java benchmarks. We demonstrate that the complex interactions of (1) architecture, (2) compiler, (3) virtual machine, (4) memory management, and (5) application require more extensive evaluation than C, C++, and Fortran which stress (4) much less, and do not require (3). We use and introduce new value, time-series, and statistical metrics for static and dynamic properties such as code complexity, code size, heap composition, and pointer mutations. No benchmark suite is definitive, but these metrics show that DaCapo improves over SPEC Java in a variety of ways, including more complex code, richer object behaviors, and more demanding memory system requirements. This paper takes a step towards improving methodologies for choosing and evaluating benchmarks to foster innovation in system design and implementation for Java and other managed languages.
Virgil
Authors: Titzer Ben L.
Published: January 2007

Embedded microcontrollers are becoming increasingly prolific, serving as the primary or auxiliary processor in products and research systems from microwaves to sensor networks. Microcontrollers represent perhaps the most severely resource-constrained embedded processors, often with as little as a few bytes of memory and a few kilobytes of code space. Language and compiler technology has so far been unable to bring the benefits of modern object-oriented languages to such processors. In this paper, I will present the design and implementation of Virgil, a lightweight object-oriented language designed with careful consideration for resource-limited domains. Virgil explicitly separates
initialization time
from runtime, allowing an application to build complex data structures during compilation and then run directly on the bare hardware without a virtual machine or any language runtime. This separation allows the entire program heap to be available at compile time and enables three new data-sensitive optimizations:
reachable members analysis, reference compression
, and
ROM-ization
. Experi-mental results demonstrate that Virgil is well suited for writing microcontroller programs, with five demonstrative applications fitting in less than 256 bytes of RAM with fewer than 50 bytes of metadata. Further results show that the optimizations presented in this paper reduced code size between 20% and 80% and RAM size by as much as 75%.
Replay compilation
Authors: Ogata Kazunori , Onodera Tamiya , Kawachiya Kiyokuni , Komatsu Hideaki , Nakatani Toshio
Published: January 2007

The performance of Java has been tremendously improved by the advance of Just-in-Time (JIT) compilation technologies. However, debugging such a dynamic compiler is much harder than a static compiler. Recompiling the problematic method to produce a diagnostic output does not necessarily work as expected, because the compilation of a method depends on runtime information at the time of compilation.In this paper, we propose a new approach, called
replay JIT compilation
, which can reproduce the same compilation remotely by using two compilers, the
state-saving compiler
and the
replaying compiler
. The state-saving compiler is used in a normal run, and, while compiling a method, records into a
log
all of the input for the compiler. The replaying compiler is then used in a debugging run with the system dump, to recompile a method with the options for diagnostic output. We reduced the overhead to save the input by using the system dump and by categorizing the input based on how its value changes. In our experiment, the increase of the compilation time for saving the input was only 1%, and the size of the additional memory needed for saving the input was only 10% of the compiler-generated code.
Concepts
Authors: Gregor Douglas , Järvi Jaakko , Siek Jeremy , Stroustrup Bjarne , Dos Reis Gabriel , Lumsdaine Andrew
Published: January 2007

Generic programming has emerged as an important technique for the development of highly reusable and efficient software libraries. In C++, generic programming is enabled by the flexibility of templates, the C++ type parametrization mechanism. However, the power of templates comes with a price: generic (template) libraries can be more difficult to use and develop than non-template libraries and their misuse results in notoriously confusing error messages. As currently defined in C++98, templates are unconstrained, and type-checking of templates is performed late in the compilation process, i.e., after the use of a template has been combined with its definition. To improve the support for generic programming in C++, we introduce
concepts
to express the syntactic and semantic behavior of types and to constrain the type parameters in a C++ template. Using concepts, type-checking of template definitions is separated from their uses, thereby making templates easier to use and easier to compile. These improvements are achieved without limiting the flexibility of templates or decreasing their performance - in fact their expressive power is increased. This paper describes the language extensions supporting concepts, their use in the expression of the C++ Standard Template Library, and their implementation in the ConceptGCC compiler. Concepts are candidates for inclusion in the upcoming revision of the ISO C++ standard, C++0x.
A formal framework for component deployment
Authors: Liu Yu David , Smith Scott F.
Published: January 2007

Software deployment is a complex process, and industrial-strength frameworks such as .NET, Java, and CORBA all provide explicit support for component deployment. However, these frameworks are not built around fundamental principles as much as they are engineering efforts closely tied to particulars of the respective systems. Here we aim to elucidate the fundamental principles of software deployment, in a platform-independent manner. Issues that need to be addressed include deployment unit design,
when, where
and
how
to wire components together, versioning, version dependencies, and hot-deployment of components. We define the
application buildbox
as the place where software is developed and deployed, and define a formal Labeled Transition System (LTS) on the buildbox with transitions for deployment operations that include build, install, ship, and update. We establish formal properties of the LTS, including the fact that if a component is shipped with a certain version dependency, then at run time that dependency must be satisfied with a compatible version. Our treatment of deployment is both platform- and vendor-independent, and we show how it models the core mechanisms of the industrial-strength deployment frameworks.
XSnippet
Authors: Sahavechaphan Naiyana , Claypool Kajal
Published: January 2007

It is common practice for software developers to use
examples
to guide development efforts. This largely unwritten, yet standard, practice of "develop by example" is often supported by examples bundled with library or framework packages, provided in textbooks, and made available for download on both official and unofficial web sites. However, the vast number of examples that are embedded in the billions of lines of already developed library and framework code are largely untapped. We have developed
XSnippet
, a context-sensitive code assistant framework that allows developers to query a sample repository for code snippets that are relevant to the programming task at hand. In particular, our work makes three primary contributions. First, a range of queries is provided to allow developers to switch between a context-independent retrieval of code snippets to various degrees of context-sensitive retrieval for object instantiation queries. Second, a novel graph-based code mining algorithm is provided to support the range of queries and enable mining within and across method boundaries. Third, an innovative context-sensitive ranking heuristic is provided that has been experimentally proven to provide better ranking for best-fit code snippets than context-independent heuristics such as shortest path and frequency. Our experimental evaluation has shown that
XSnippet
has significant potential to assist developers, and provides better coverage of tasks and better rankings for best-fit snippets than other code assistant systems.
Intentional software
Authors: Simonyi Charles , Christerson Magnus , Clifford Shane
Published: January 2007

Wysiwyg editors simplified document creation by separating the document contents from the looks and by automating the re-application of the looks to changing contents. In the same way Intentional Software simplifies software creation by separating the software contents in terms of their various domains from the implementation of the software and by enabling automatic re-generation of the software as the contents change. This way, domain experts can work in parallel with programmers in their respective areas of expertise; and the repeated intermingling can be automated. Intentional Software is supported by a Domain Workbench tool where multiple domains can be defined, created, edited, transformed and integrated during software creation. Key features include a uniform representation of multiple interrelated domains, the ability to project the domains in multiple editable notations, and simple access for a program generator.
A survey on ontology mapping
Authors: Choi Namyoun , Song Il-Yeol , Han Hyoil
Published: January 2007

Ontology is increasingly seen as a key factor for enabling interoperability across heterogeneous systems and semantic web applications. Ontology mapping is required for combining distributed and heterogeneous ontologies. Developing such ontology mapping has been a core issue of recent ontology research. This paper presents ontology mapping categories, describes the characteristics of each category, compares these characteristics, and surveys tools, systems, and related work based on each category of ontology mapping. We believe this paper provides readers with a comprehensive understanding of ontology mapping and points to various research topics about the specific roles of ontology mapping.
Tradeoffs in transactional memory virtualization
Authors: Chung JaeWoong , Minh Chi Cao , McDonald Austen , Skare Travis , Chafi Hassan , Carlstrom Brian D. , Kozyrakis Christos , Olukotun Kunle
Published: January 2007

For transactional memory (TM) to achieve widespread acceptance, transactions should not be limited to the physical resources of any specific hardware implementation. TM systems should guarantee correct execution even when transactions exceed scheduling quanta, overflow the capacity of hardware caches and physical memory, or include more independent nesting levels than what is supported in hardware. Existing proposals for TM virtualization are either incomplete or rely on complex hardware implementations, which are an overkill if virtualization is invoked infrequently in the common case.We present
eXtended Transactional Memory
(XTM), the first TM virtualization system that virtualizes all aspects of transactional execution (time, space, and nesting depth). XTM is implemented in software using virtual memory support. It operates at page granularity, using private copies of overflowed pages to buffer memory updates until the transaction commits and snapshots of pages to detect interference between transactions. We also describe two enhancements to XTM that use limited hardware support to address key performance bottlenecks.We compare XTM to hardwarebased virtualization using both real applications and synthetic microbenchmarks. We show that despite being software-based, XTM and its enhancements are competitive with hardware-based alternatives. Overall, we demonstrate that XTM provides a complete, flexible, and low-cost mechanism for practical TM virtualization.
A regulated transitive reduction (RTR) for longer memory race recording
Authors: Xu Min , Hill Mark D. , Bodik Rastislav
Published: January 2007

Now at VMware. Multithreaded deterministic replay has important applications in cyclic debugging, fault tolerance and intrusion analysis. Memory race recording is a key technology for multithreaded deterministic replay. In this paper, we considerably improve our previous always-on Flight Data Recorder (FDR) in four ways:
•Longer recording
by reducing the log size growth rate to approximately one byte per thousand dynamic instructions.
•Lower hardware cost
by reducing the cost to 24 KB per processor core.
•Simpler design
by modifying only the cache coherence protocol, but not the cache.
•Broader applicability
by supporting both Sequential Consistency (SC) and Total Store Order (TSO) memory consistency models (existing recorders support only SC).These improvements stem from several ideas: (1) a
Regulated Transitive Reduction (RTR)
recording algorithm that creates stricter and vectorizable dependencies to reduce the log growth rate; (2) a
Set/LRU
timestamp approximation method that better approximates timestamps of uncached memory locations to reduce the hardware cost; (3) an
order-value-hybrid
recording methodthat explicitly logs the value of potential SC-violating load instructions to support multiprocessor systems with TSO.
Bell
Authors: Bond Michael D. , McKinley Kathryn S.
Published: January 2007

Memory leaks compromise availability and security by crippling performance and crashing programs. Leaks are difficult to diagnose because they have no immediate symptoms. Online leak detection tools benefit from storing and reporting per-object
sites
(e.g., allocation sites) for potentially leaking objects. In programs with many small objects, per-object sites add high space overhead, limiting their use in production environments.This paper introduces
Bit-Encoding Leak Location
(Bell), a statistical approach that
encodes
per-object sites to a single bit per object. A bit loses information about a site, but given sufficient objects that use the site and a known, finite set of possible sites, Bell uses brute-force
decoding
to recover the site with high accuracy.We use this approach to encode object allocation and last-use sites in
Sleigh
, a new leak detection tool. Sleigh detects
stale
objects (objects unused for a long time) and uses Bell decoding to report their allocation and last-use sites. Our implementation steals four unused bits in the object header and thus incurs no per-object space overhead. Sleigh's instrumentation adds 29% execution time overhead, which adaptive profiling reduces to 11%. Sleigh's output is directly useful for finding and fixing leaks in SPEC JBB2000 and Eclipse, although sufficiently many objects must leak before Bell decoding can report sites with confidence. Bell is suitable for other leak detection approaches that store per-object sites, and for other problems amenable to statistical per-object metadata.
SlicK
Authors: Parashar Angshuman , Sivasubramaniam Anand , Gurumurthi Sudhanva
Published: January 2007

Transient faults are expected a be a major design consideration in future microprocessors. Recent proposals for transient fault detection in processor cores have revolved around the idea of redundant threading, which involves redundant execution of a program across multiple execution contexts. This paper presents a new approach to redundant threading by bringing together the concepts of slice-level execution and value and control-flow locality into a novel partial redundant threading mechanism called
SlicK
.The purpose of redundant execution is to check the integrity of the outputs propagating out of the core (typically through stores). SlicK implements redundancy at the granularity of backward-slices of these output instructions and exploits value and control-flow locality to avoid redundantly executing slices that lead to predictable outputs, thereby avoiding redundant execution of a significant fraction of instructions while maintaining extremely low vulnerabilities for critical processor structures.We propose the microarchitecture of a backward-slice extractor called SliceEM that is able to identify backward slices without interrupting the instruction flow, and show how this extractor and a set of predictors can be integrated into a redundant threading mechanism to form SlicK. Detailed simulations with SPEC CPU2000 benchmarks show that SlicK can provide around 10.2% performance improvement over a well known redundant threading mechanism, buying back over 50% of the loss suffered due to redundant execution. SlicK can keep the Architectural Vulnerability Factors of processor structures to typically 0%-2%. More importantly, SlicK's slice-based mechanisms provide future opportunities for exploring interesting points in the performance-reliability design space based on market segment needs.
Integrated network interfaces for high-bandwidth TCP/IP
Authors: Binkert Nathan L. , Saidi Ali G. , Reinhardt Steven K.
Published: January 2007

This paper proposes new network interface controller (NIC) designs that take advantage of integration with the host CPU to provide increased flexibility for operating system kernel-based performance optimization.We believe that this approach is more likely to meet the needs of current and future high-bandwidth TCP/IP networking on end hosts than the current trend of putting more complexity in the NIC, while avoiding the need to modify applications and protocols. This paper presents two such NICs. The first, the simple integrated NIC (SINIC), is a minimally complex design that moves the responsibility for managing the network FIFOs from the NIC to the kernel. Despite this closer interaction between the kernel and the NIC, SINIC provides performance equivalent to a conventional DMA-based NIC without increasing CPU overhead. The second design, V-SINIC, adds virtual per-packet registers to SINIC, enabling parallel packet processing while maintaining a FIFO model. V-SINIC allows the kernel to decouple examining a packet's header from copying its payload to memory. We exploit this capability to implement a true zero-copy receive optimization in the Linux 2.6 kernel, providing bandwidth improvements of over 50% on unmodified sockets-based receive-intensive benchmarks.
Temporal search
Authors: Crandall Jedidiah R. , Wassermann Gary , de Oliveira Daniela A. S. , Su Zhendong , Wu S. Felix , Chong Frederic T.
Published: January 2007

Worms, viruses, and other malware can be ticking bombs counting down to a specific time, when they might, for example, delete files or download new instructions from a public web server. We propose a novel virtual-machine-based analysis technique to automatically discover the
timetable
of a piece of malware, or when events will be triggered, so that other types of analysis can discern what those events are. This information can be invaluable for responding to rapid malware, and automating its discovery can provide more accurate information with less delay than careful human analysis.Developing an automated system that produces the timetable of a piece of malware is a challenging research problem. In this paper, we describe our implementation of a key component of such a system: the discovery of timers without making assumptions about the integrity of the infected system's kernel. Our technique runs a virtual machine at slightly different rates of
perceived time
(time as seen by the virtual machine), and identifies time counters by correlating memory write frequency to timer interrupt frequency.We also analyze real malware to assess the feasibility of using full-system, machine-level symbolic execution on these timers to discover predicates. Because of the intricacies of the Gregorian calendar (leap years, different number of days in each month, etc.) these predicates will not be direct expressions on the timer but instead an annotated trace; so we formalize the calculation of a timetable as a weakest precondition calculation. Our analysis of six real worms sheds light on two challenges for future work: 1) time-dependent malware behavior often does not follow a linear timetable; and 2) that an attacker with knowledge of the analysis technique can evade analysis. Our current results are promising in that with simple symbolic execution we are able to discover predicates on the day of the month for four real worms. Then through more traditional manual analysis we conclude that a more control-flow-sensitive symbolic execution implementation would discover all predicates for the malware we analyzed.
The animated short
Authors: Bannan Patrick , Netzband Thomas
Published: January 2007

To the fledgling, painfully green animation students of the world, the universe of film making and production oriented projects can seem profoundly mysterious and annoyingly inaccessible...and in the real world, "working man" sense of things...it is. It was to my surprise, honor, hint of fear, and "helping" of confusion then, when, upon learning of a recent victory of The National Team Animation Competition (sponsored by HP and Saytek) my Department Director at The Art Institute of Pittsburgh, Hans Westman, asked myself and another fellow teammate to write an article talking about the production experience as a whole.
Safety, security, and object-oriented programming
Authors: Gasperoni Franco
Published: January 2007

When safety-critical software malfunctions people lives are in danger. When security-critical software is cracked national security or economic activity may be at risk.As more and more software embraces object-oriented programming (OOP) safety-critical and security-critical projects feel compelled to use object-orientation. But what are the guarantees of OOP in terms of safety and security? Are the design goals of OOP aligned with those of safe and secure software (
S
3
) systems?In the following sections we look at key OOP aspects and analyze some of the hazards they introduce with respect to
S
3
and outline a possible way of addressing these vulnerabilities. Specifically, after a quick overview of OOP in section 2, section 3 deals with inheritance and shows some of its hazards in terms of
S
3
along with possible remedies. Section 4 focuses on dynamic binding and suggests a safer and more secure implementation than what is conventionally done. Finally, section 5 looks at testing programs with dynamic binding.
Let the sisters speak
Authors: Kvasny Lynette
Published: January 2007

In this paper, I examine how and why the situated knowledge and lived experiences of working-class African American women shape their standpoint on information technology (IT). Using the biblical metaphor of the exodus and narratives of ascent, these women view IT access and training as part of a strategy for escaping poverty and despair. Whereas most of the extant gender and IT research provides rich insights into the marginalization of women, the women in this study felt empowered by IT. This contradictory outcome has three implications for the study of gender and IT. First, researchers must consider the multiple identities such as gender, race, ethnicity, socio-economic status, and sexuality that shape and are shaped by women's engagement with IT. Second, the notion of IT workforce should take into account not only the highly skilled IT workers who design and build IT artifacts, but should also consider the lower skilled workers who indirectly use IT. Third, IT training programs that serve working-class women must go beyond the transfer of IT skills to individuals. They must also redress the persistent structural barriers of poverty, spatial isolation, illiteracy, sporadic work, and racial and ethnic discrimination that systematically limit women's ability to compete for jobs that provide higher incomes, greater safety, more security, full-time hours, increased benefits, higher status, and less stressful work environments.
Is the information systems profession gendered?
Authors: Joshi K. D. , Schmidt Nancy L.
Published: January 2007

In spite of a more "feminine" nature of the information systems (IS) discipline due to its greater perceived social component, stereotypes and educational prejudices that are prevalent in the computer science discipline are assumed to exist in the information systems field. The objective of this study is to test the validity of this assumption by uncovering the perceptions of college students toward IS professionals and the IS profession. Our study reveals that stereotypes found to be associated with computer science also seem to permeate the IS field. However, after students are exposed to IS careers, they appear to grasp the unique nature of IS. In other words, while describing an IS professional and the IS profession, men and women were cognizant that the IS profession is a blend of technical, systems, social, and managerial components. This study also sheds some light on the question - Is the IS profession perceived to be gendered? Based on the study's results, we conclude that the students' perceptions of IS careers are to some extent gendered with a greater emphasis on masculine than feminine or gender neutral traits and abilities.
Automatic OO parser generation using visitors for Ada 2005
Authors: Carlisle Martin C.
Published: January 2007

We describe AdaGOOP 2005 (the Ada Generator of Object-Oriented Parsers). AdaGOOP 2005 takes a specification of tokens and an LALR(1) grammar and creates a lexer, a parser that automatically creates a parse tree, and a traversal of the parse tree using the visitor pattern. AdaGOOP generates output that is similar to that of the Java tool SableCC. It takes advantage of the new interface feature available in Ada 2005 to create a visitor.
DEGAS
Authors: Ludwig Luke , Pukite Paul
Published: January 2007

DEGAS provides discrete-event scheduling capability to a GNAT Ada program without requiring extra calls to a simulation library. We accomplish this by intercepting all calls destined for the pthread library and then rerouting them to the dynamically linked DEGAS library; this allows a developer to switch between real-time and discrete-event modes at runtime in a non-intrusive manner. DEGAS narrows the separation between simulation and real time applications, and has significant implications for software that includes elements of concurrency, synchronization, and time. We foresee applications that go beyond simulations, including executable specifications, algorithm development, and system verification.