waashk/dblp huggingface dataset:
a hybrid local-global approach for multi-core thermal management. multi-core processors have become an integral part of mainstream high performance computer systems. in parallel, exponentially increasing power density and packaging costs have necessitated system level thermal management solutions for multi-core systems. dynamic thermal management (dtm) techniques monitor on-chip temperature continuously and typically employs dynamic voltage and frequency scaling (dvfs) to lower the temperature when it exceeds a pre-defined threshold. state-of-the-art dtm solutions for multi-core systems include distributed dvfs (where each core can scale the voltage/frequency individually) and global dvfs (where all cores scale voltage/frequency simultaneously). distributed dvfs generally offers higher performance than global dvfs, but it is hard to implement and has major scalability issues. we propose a hybrid local-global thermal management approach for multi-core systems that offers better performance than distributed dvfs, while maintaining the simplicity of global dvfs. we employ global dvfs across all the cores but locally tune the performance of each core individually through architectural adaptations. we exploit easily reconfigurable micro-architecture parameters such as instruction window size, issue width, and fetch throttling in per-core thermal management. our hybrid solution is easy to implement and highly effective towards temperature management. the key challenge is appropriate choice of configurations at runtime to provide optimal performance under thermal constraints. we formulate it as a configuration search problem and design an efficient software-based solution that selects the appropriate configuration. our hybrid method, though simpler to implement, achieves 5% better throughput compared to distributed dvfs.
a hierarchy of subgraphs underlying a timing graph and its use in capturing topological correlation in ssta. this paper shows that a timing graph has a hierarchy of specially defined subgraphs, based on which we present a technique that captures topological correlation in arbitrary block-based statistical static timing analysis (ssta). we interpret a timing graph as an algebraic expression made up of addition and maximum operators. we define the division operation on the expression and propose algorithms that modify factors in the expression without expansion. as a result, they produce an expression to derive the latest arrival time with better accuracy in ssta. existing techniques handling reconvergent fanouts usually use dependency lists, requiring quadratic space complexity. instead, the proposed technique has linear space complexity by using a new directed acyclic graph search algorithm. our results show that it outperforms an existing technique in speed and memory usage with comparable accuracy.
power7 - verification challenge of a multi-core processor. over the years functional hardware verification has made significant progress in the areas of traditional simulation techniques, hardware accelerator usage and last but not least formal verification approaches. this has been sufficient to deal with the additional design content and complexity increase that has been happening at the same time. for power7, ibm's first high end 8-core microprocessor, these incremental improvements in verification have been deemed not to be enough by themselves, because the chip was not just a remap of an existing design with more cores. the infrastructure on the chip had to be changed significantly, while at the same time the business side requested a shorter development cycle with perfect quality but without growing the team. looking at these constraints a two phase approach seemed to be the only solution. this paper commences with the highlights of the first phase, where improvements to the existing process have been identified. this includes topics ranging from enhanced test case generation, over advancements in structural checking to the extensions of the formal verification scope both in property checking and sequential equivalence checking. at the same time, the paper describes the second phase which has targeted the exploitation of synergy across the various verification activities. the active interlock between simulation, formal verification and the design has helped to reduce workload and improved the project schedule. and the usage of coverage in holistic way from unit level simulation to acceleration has led to new innovations and new insight, which improved the overall verification process. finally, an outlook on future challenges and future trends is given.
obstacle-avoiding rectilinear steiner tree construction based on steiner point selection. for the obstacle-avoiding rectilinear steiner minimal tree (oarsmt) problem, this paper presents a steiner-point based algorithm to achieve the best practical performance in wirelength and run time. unlike many previous works, the steiner-based framework is more focused on the usage of steiner points instead of the handling of obstacles. this paper also proposes a new concept of steiner point locations to provide an effective as well as efficient way to generate desirable steiner point candidates. experimental results show that this algorithm achieves the best solution quality in &theta; (n log n) empirical time, which was originally generated by applying the maze routing on an &omega;(n2)-space graph. the steiner-point based framework and the new concept of steiner point locations can be applied to future research on the oarsmt problem and its generations, such as the multi-layer oarsmt problem.
crisp: congestion reduction by iterated spreading during placement. dramatic progress has been made in algorithms for placement and routing over the last 5 years, with improvements in both speed and quality. combining placement and routing into a joint optimization has also been proposed. however, it remains unclear if the benefits would be significant enough to justify major changes in commercial tools. crisp addresses this challenge and is the first tool to demonstrate tangible benefits of combined place-and-route optimization including fewer global routing detours, reduced detailed routing violations and runtime, and even shrinking the floorplan of a commercial design. we employ fast global routing to choose standard cells to temporarily inflate and iteratively spread for congestion reduction. spreading only in congested regions, we enable die area reduction by facilitating routing with high area utilization.
resilient circuits - enabling energy-efficient performance and reliability. voltage and frequency margins necessary to ensure correct processor operation under dynamic voltage, temperature, and aging variations result in performance and power overheads. resilient circuit techniques, including embedded error-detection sequentials and tunable replica circuits, allow these margins to be reduced or eliminated, resulting in reliable, energy-efficient operation.
a study of routability estimation and clustering in placement. this paper studies the effects of clustering as a pre-processing step and routability estimation in the placement flow. the study shows that when clustering and routability estimation are considered, the placer effectively improves the routed wirelength for the circuits of ibm-place 2.0 standard-cell benchmark suite [1] and results in the best average routed wirelength when compared against state-of-the-art academic placers.
fast 3-d thermal analysis of complex interconnect structures using electrical modeling and simulation methodologies. accurate and fast estimation of vlsi interconnect thermal profiles has become critically important to estimate their impact on circuit/system performance and reliability, which is necessary for reducing product development time and achieving first-pass silicon success. present commercial thermal analysis tools are incapable of simulating complex structures, particularly in the 3-d domain and are also difficult to integrate with existing design tools. existing analytical thermal models are not perfect either: they are either not accurate enough or oversimplified. this paper uses a methodology, which exploits existing electrical resistance solvers for thermal simulation, to allow fast acquisition of thermal profiles of complex interconnect structures with good accuracy and reasonable computation cost. moreover, for the first time, an accurate closed-form thermal model is developed. the model allows for an equivalent medium with effective thermal conductivity (isotropic or anisotropic) to replace the detailed material information in non-critical regions so that complex interconnect structures can be simulated. using these techniques, this paper demonstrates the simulation of a very complex interconnect structure (~9000 objects or 15 million meshed unknowns after first order isotropic equivalent medium replacement), which is a first time achievement in the area of interconnect thermal analysis. on the other hand, it is shown that an anisotropic equivalent medium is a much better approximation of real interconnect structures from the point of view of accuracy and computation.
constraint solving techniques for software testing and analysis. software testing and analysis are very important research topics in software engineering. we are interested in improving the accuracy of analysis, as well as automation of test generation. in particular, we have been working on the automatic generation of small orthogonal arrays which can be used for combinatorial testing, and the computation of path execution frequency for a program path. the basic idea is to reduce the original problems to constraint satisfaction problems and develop effective constraint solving techniques for solving the problems.
using symbolic evaluation to understand behavior in configurable software systems. many modern software systems are designed to be highly configurable, which increases flexibility but can make programs hard to test, analyze, and understand. we present an initial empirical study of how configuration options affect program behavior. we conjecture that, at certain levels of abstraction, configuration spaces are far smaller than the worst case, in which every configuration is distinct. we evaluated our conjecture by studying three configurable software systems: vsftpd, ngircd, and grep. we used symbolic evaluation to discover how the settings of run-time configuration options affect line, basic block, edge, and condition coverage for our subjects under a given test suite. our results strongly suggest that for these subject programs, test suites, and configuration options, when abstracted in terms of the four coverage criteria above, configuration spaces are in fact much smaller than combinatorics would suggest and are effectively the composition of many small, self-contained groupings of options.
from behaviour preservation to behaviour modification: constraint-based mutant generation. the efficacy of mutation analysis depends heavily on its capability to mutate programs in such a way that they remain executable and exhibit deviating behaviour. whereas the former requires knowledge about the syntax and static semantics of the programming language, the latter requires some least understanding of its dynamic semantics, i.e., how expressions are evaluated. we present an approach that is knowledgeable enough to generate only mutants that are both syntactically and semantically correct and likely exhibit non-equivalent behaviour. our approach builds on our own prior work on constraint-based refactoring tools, and works by negating behaviour-preserving constraints. as a proof of concept we present an enhanced implementation of the access modifier change operator for java programs whose naive implementations create huge numbers of mutants that do not compile or leave behaviour unaltered. while we cannot guarantee that our generated mutants are non-equivalent, we can demonstrate a considerable reduction in the number of vain mutant generations, leading to substantial temporal savings.
advanced hands-on training for distributed and outsourced software engineering. today's software projects are often distributed across multiple locations. this distribution poses new challenges produced by the cooperation across different countries, times zones, and cultures. software engineering courses have to prepare students accordingly. this paper reports an experience on teaching a distributed software engineering course. in this course, students develop software in collaboration with five universities located in italy, hungary, russia, switzerland, and ukraine. the projects allow students to face the difficulties of developing software in a globalized context, and provide a practical experience on distributed software engineering. we describe the major obstacles on organizing such a course, and we suggest best practices to achieve successful outcome.
linking e-mails and source code artifacts. e-mails concerning the development issues of a system constitute an important source of information about high-level design decisions, low-level implementation concerns, and the social structure of developers. establishing links between e-mails and the software artifacts they discuss is a non-trivial problem, due to the inherently informal nature of human communication. different approaches can be brought into play to tackle this trace-ability issue, but the question of how they can be evaluated remains unaddressed, as there is no recognized benchmark against which they can be compared. in this article we present such a benchmark, which we created through the manual inspection of a statistically significant number of e-mails pertaining to six unrelated software systems. we then use our benchmark to measure the effectiveness of a number of approaches, ranging from lightweight approaches based on regular expressions to full-fledged information retrieval approaches.
a discriminative model approach for accurate duplicate bug report retrieval. bug repositories are usually maintained in software projects. testers or users submit bug reports to identify various issues with systems. sometimes two or more bug reports correspond to the same defect. to address the problem with duplicate bug reports, a person called a triager needs to manually label these bug reports as duplicates, and link them to their "master" reports for subsequent maintenance work. however, in practice there are considerable duplicate bug reports sent daily; requesting triagers to manually label these bugs could be highly time consuming. to address this issue, recently, several techniques have be proposed using various similarity based metrics to detect candidate duplicate bug reports for manual verification. automating triaging has been proved challenging as two reports of the same bug could be written in various ways. there is still much room for improvement in terms of accuracy of duplicate detection process. in this paper, we leverage recent advances on using discriminative models for information retrieval to detect duplicate bug reports more accurately. we have validated our approach on three large software bug repositories from firefox, eclipse, and openoffice. we show that our technique could result in 17--31%, 22--26%, and 35--43% relative improvement over state-of-the-art techniques in openoffice, firefox, and eclipse datasets respectively using commonly available natural language information only.
codebook: discovering and exploiting relationships in software repositories. large-scale software engineering requires communication and collaboration to successfully build and ship products. we conducted a survey with microsoft engineers on inter-team coordination and found that the most impactful problems concerned finding and keeping track of other engineers. since engineers are connected by their shared work, a tool that discovers connections in their work-related repositories can help. here we describe the codebook framework for mining software repositories. it is flexible enough to address all of the problems identified by our survey with a single data structure (graph of people and artifacts) and a single algorithm (regular language reachability). codebook handles a larger variety of problems than prior work, analyzes more kinds of work artifacts, and can be customized by and for end-users. to evaluate our framework's flexibility, we built two applications, hoozizat and deep intellisense. we evaluated these applications with engineers to show effectiveness in addressing multiple inter-team coordination problems.
dynamic service quality and resource negotiation for high-availability service-oriented systems. the principle goal of our research project is to improve the availability of service-oriented systems. this is especially important in systems that cross organizational boundaries. in this paper we outline the main research questions, our approach, which is based on appropriate redundancy strategies, and the progress achieved to date.
precise calling context encoding. calling contexts are very important for a wide range of applications such as profiling, debugging, and event logging. most applications perform expensive stack walking to recover contexts. the resulting contexts are often explicitly represented as a sequence of call sites and hence bulky. we propose a technique to encode the current calling context of any point during an execution. in particular, an acyclic call path is encoded into one number through only integer additions. recursive call paths are divided into acyclic subsequences and encoded independently. we leverage stack depth in a safe way to optimize encoding: if a calling context can be safely and uniquely identified by its stack depth, we do not perform encoding. we propose an algorithm to seamlessly fuse encoding and stack depth based identification. the algorithm is safe because different contexts are guaranteed to have different ids. it also ensures contexts can be faithfully decoded. our experiments show that our technique incurs negligible overhead (1.89% on average). for most medium-sized programs, it can encode all contexts with just one number. for large programs, we are able to encode most calling contexts to a few numbers.
towards end-user enabled web service consumption for mashups. services oriented architecture (soa) and web 2.0 are two complementary trends towards a programmable web. in this respect, the ws-* stack became pervasive for enterprise application integration and mashups attracted interest as novel web 2.0 applications combining heterogeneous web sources. while most mashup tools focus on the integration of lightweight web services (i.e. rss/atom, rest), evolving enterprise mashups particularly need to integrate ws-* for enterprise-class data and logic. hence, it requires experienced developers to prepare rather complex ws-* (e.g. as widgets) to enable casual developers and business users to create mashups. therefore, we postulate the hypothesis that this requires an a-priori simplification and cognitive support. in this abstract, we propose a research agenda on how to address such a simplification approach for enterprise services to ultimately empower business users to create real enterprise-class mashups.
characterizing and predicting which bugs get fixed: an empirical study of microsoft windows. we performed an empirical study to characterize factors that affect which bugs get fixed in windows vista and windows 7, focusing on factors related to bug report edits and relationships between people involved in handling the bug. we found that bugs reported by people with better reputations were more likely to get fixed, as were bugs handled by people on the same team and working in geographical proximity. we reinforce these quantitative results with survey feedback from 358 microsoft employees who were involved in windows bugs. survey respondents also mentioned additional qualitative influences on bug fixing, such as the importance of seniority and interpersonal skills of the bug reporter. informed by these findings, we built a statistical model to predict the probability that a new bug will be fixed (the first known one, to the best of our knowledge). we trained it on windows vista bugs and got a precision of 68% and recall of 64% when predicting windows 7 bug fixes. engineers could use such a model to prioritize bugs during triage, to estimate developer workloads, and to decide which bugs should be closed or migrated to future product versions.
an exploratory study of the evolution of software licensing. free and open source software systems (foss) are distributed and made available to users under different software licenses, mentioned in foss code by means of licensing statements. various factors, such as changes in the legal landscape, commercial code licensed as foss, or code reused from other foss systems, lead to evolution of licensing, which may affect the way a system or part thereof can be subsequently used. therefore, it is crucial to monitor licensing evolution. however, manually tracking the licensing evolution of thousands of files is a daunting task. after presenting several cases of the effects of licensing evolution, we propose an approach to automatically track changes occurring in the licensing terms of a system. then, we report an empirical study of the licensing evolution of six different foss systems. results show that licensing underwent frequent and substantial changes.
using information fragments to answer the questions developers ask. each day, a software developer needs to answer a variety of questions that require the integration of different kinds of project information. currently, answering these questions, such as "what have my co-workers been doing?", is tedious, and sometimes impossible, because the only support available requires the developer to manually link and traverse the information step-by-step. through interviews with eleven professional developers, we identified 78 questions developers want to ask, but for which support is lacking. we introduce an information fragment model (and prototype tool) that automates the composition of different kinds of information and that allows developers to easily choose how to display the composed information. in a study, 18 professional developers used the prototype tool to answer eight of the 78 questions. all developers were able to easily use the prototype to successfully answer 94% of questions in a mean time of 2.3 minutes per question.
south africa and the world beyond 2010: the latest scenarios. the talk will address the following issues: &bull; what does it take to be a futurist in today's fast-changing world particularly in it? &bull; is the world economy in a u-shaped recession which could last another 5 years or has the recovery begun. what are the flags to suggest which scenario is in play? &bull; what is the profile of a winning nation and does south africa fit the bill? &bull; are you a fox or a hedgehog? the acm portal is published by the association for computing machinery. copyright © 2010 acm, inc. terms of usage privacy policy code of ethics contact us useful downloads: adobe acrobat quicktime windows media player real player
a large-scale empirical study of practitioners' use of object-oriented concepts. we present the first results from a survey carried out over the second quarter of 2009 examining how theories in object-oriented design are understood and used by software developers. we collected 3785 responses from software developers world-wide, which we believe is the largest survey of its kind. we targeted the use of encapsulation, class size as measured by number of methods, and depth of a class in the inheritance hierarchy. we found that, while overall practitioners followed advice on encapsulation, there was some variation of adherence to it. for class size and depth there was substantially less agreement with expert advice. in addition, inconsistencies were found within the use and perception of object-oriented concepts within the investigated group of developers. the results of this survey has deep reaching consequences for both practitioners and researchers as they highlight and confirm central issues.