Search

The problem of allocating and scheduling precedence-constrained tasks on the processors of a distributed real-time system is NP-hard. As such, it has been traditionally tackled by means of heuristics, which provide only approximate or near-optimal solutions. This paper proposes a complete allocation and scheduling framework, and deploys an MPSoC virtual platform to validate the accuracy of modelling assumptions. The optimizer implements an efficient and exact approach to the mapping problem based on a decomposition strategy. The allocation subproblem is solved through Integer Programming (IP) while the scheduling one through Constraint Programming (CP). The two solvers interact by means of an iterative procedure which has been proven to converge to the optimal solution. Experimental results show significant speed-ups w.r.t. pure IP and CP exact solution strategies as well as high accuracy with respect to cycle-accurate functional simulation. Two case studies further demonstrate the practical viability of our framework for real-life applications. [ABSTRACT FROM AUTHOR]

Abstract: CommUnity is a formal approach to Software Architecture with a strict separation of the computation, coordination, and distribution aspects. The approach is based on a parallel design language with state, which facilitates the specification of computations compared to the process calculi used by other formal approaches, and on category theory, which provides an intuitive yet precise graph-based semantics for the configuration of components and connectors. The CommUnity Workbench is being developed as a proof of concept of the CommUnity framework, providing a graphical integrated development environment to write components, draw configurations, and execute the resulting system. [Copyright &y& Elsevier]

Structured adaptive mesh refinement (SAMR) techniques provide an effective means for dynamically concentrating computational effort and resources to appropriate regions in the application domain. However, due to their dynamism and space-time heterogeneity, scalable parallel implementation of SAMR applications remains a challenge. This paper investigates hybrid runtime management strategies and presents an adaptive hierarchical multipartitioner (AHMP) framework. AHMP dynamically applies multiple partitioners to different regions of the domain, in a hierarchical manner, to match the local requirements of the regions. Key components of the AHMP framework include a segmentation-based clustering algorithm (SBC) that can efficiently identify regions in the domain with relatively homogeneous partitioning requirements, mechanisms for characterizing the partitioning requirements of these regions, and a runtime system for selecting, configuring, and applying the most appropriate partitioner to each region. Further, to address dynamic resource situations for long-running applications, AHMP provides a hybrid partitioning strategy (HPS) that involves application-level pipelining, trading space for time when resources are sufficiently large and underutilized, and an application-level out-of-core strategy (ALOC), trading time for space when resources are scarce in order to enhance the survivability of applications. The AHMP framework has been implemented and experimentally evaluated on up to 1,280 processors of the IBM SP4 cluster at the San Diego Supercomputer Center. [ABSTRACT FROM AUTHOR]

Application-level multicast is a promising alternative to IP multicast due to its independence from the IP routing infrastructure and its flexibility in constructing the delivery trees. The existing overlay multicast systems either support a single data source or have high maintenance overhead when multiple sources are allowed. They are inefficient for applications that require any-source multicast with varied host capacities and dynamic membership. This paper proposes ACOM, an any-source capacity-constrained overlay multicast system, consisting of three distributed multicast algorithms on top of a non-DHT overlay network with simple structures (random overlay with a non-DHT ring) that are easy to manage as nodes join and depart. The nodes have different capacities, and they can support different numbers of direct children during a multicast session. No explicit multicast trees are maintained on top of the overlay. The distributed execution of the algorithms naturally defines an implicit, roughly balanced, capacity-constrained multicast tree for each source node. We prove that the system can deliver a multicast message from any source to all nodes in expected O(logC n) hops, which is asymptotically optimal, where c is the average node capacity and m is the number of members in a multicast group. [ABSTRACT FROM AUTHOR]

The article presents a study that describes the overall design and architecture of the pMatlab performance with the equivalent Message Passing Interface (MPI) codes. In this study, the researchers present implementation data collected from a sample of real pMatlab applications drawn from the approximately one hundred computer users at MIT Lincoln Laboratory. Furthermore, these data show that users are typically able to go from a serial code to an efficient pMatlab code in about 3 hours while changing less than 1 percent of their code.

The article presents a study that describes a new approach to locality awareness, which focuses on data distributions in high-productivity Chapel language. Here, the researchers present an object-oriented framework that allows the explicit specification of the mapping of elements in a collection to memory units, the control of the arrangement of elements within such units, the definition of sequential and parallel iteration over collections, and the formulation of specialized allocation policies as required for advanced applications.

Amdahl’s Law is based upon two assumptions – that of boundlessness and homogeneity – and so it can fail when applied to single chip heterogeneous multiprocessor designs, and even microarchitecture. We show that a performance increase in one part of the system can negatively impact the overall performance of the system, in direct contradiction to the way Amdahl’s Law is instructed. Fundamental assumptions that are consistent with Amdahl’s Law are a heavily ingrained part of our computing design culture, for research as well as design. This paper points in a new direction. We motivate that emphasis should be made on holistic, system level views instead of divide and conquer approaches. This, in turn, has relevance to the potential impacts of custom processors, system-level scheduling strategies and the way systems are partitioned. We realize that Amdahl’s Law is one of the few, fundamental laws of computing. However, its very power is in its simplicity, and if that simplicity is carried over to future systems, we believe that it will impede the potential of future computing systems. [ABSTRACT FROM AUTHOR]

Abstract: In this paper, we propose the use of Versioned Boxes, which keep a history of values, as the basis for language-level memory transactions. Unlike previous work on software transactional memory, in our proposal read-only transactions never conflict with any other concurrent transaction. This may improve significantly the concurrency on applications which have longer transactions and a high read/write ratio. Furthermore, we discuss how we can reduce transaction conflicts by delaying computations and re-executing only parts of a transaction in case of a conflict. We propose two language-level abstractions to support these strategies: the per-transaction boxes and the restartable transactions. Finally, we lay out the basis for a more generic model, which better supports fine-grained restartable transactions. The goal of this new model is to generalize the previous two abstractions to reduce conflicts. [Copyright &y& Elsevier]

The article talks about software development optimization through software virtualization, a powerful mechanism for running multiple operating systems, as well as multiple applications on different software platforms on the same physical hardware. Virtualization approaches can be varied. These approaches include the emulation or full system virtualization, the paravirtualization, the native virtualization and the operating system-level virtualization. Virtualization can save significant capital expenditure in test infrastructure. Furthermore, it saves executing 30 percent of the product tests in the desktop environment.

Modern superscalar microprocessors need sizable register files to support a large number of in-flight instructions for exploiting instruction level parallelism (ILP). An alternative to building large register files is to use a smaller number of registers, but manage them more effectively. More efficient management of registers can also result in higher performance if the reduction of the register file size is not the goal. Traditional register file management mechanisms deallocate a physical register only when the next instruction writing to the same destination architectural register commits. In this paper, we propose several techniques for deallocating physical registers much earlier. Our designs rely on the use of a checkpointed register file (CRF), where a local shadow copy of each bitcell is used to temporarily save the values of the early deallocated registers should they be needed to recover from branch mispredictions or to reconstruct the precise state after exceptions or interrupts. The proposed techniques try to release registers as soon as possible and are more aggressive than the previously proposed schemes for early deallocation of registers. [ABSTRACT FROM AUTHOR]

Up to now, the power problems which could be caused by the huge amount of hardware resources present in modern systems have not been a primary concern. More recently, however, power consumption has begun limiting the number of resources which can be safely integrated into a single package, lest the heat dissipation exceed physical limits (before actual package meltdown). At the same time, new architectural techniques such as Simultaneous MultiThreading (SMT), whose goal it is to efficiently use the resources of a superscalar machine without introducing excessive additional control overhead, have appeared on the scene. In this paper, we present a new resource management scheme which enables an efficient low power mode in SMT architectures. The proposed scheme is based on a modified pipeline throttling technique which introduces a throttling point at the last stage of the processor pipeline in order to reduce power consumption. We demonstrate that resource utilization plays an important role in efficient power management and that our strategy can significantly improve performance in the power-saving mode. Since the proposed resource management scheme tests the processor condition cycle by cycle, we evaluate its performance by setting a target IPC as one sort of immediate power measure. Our analysis shows that an SMT processor with our dynamic resource management scheme can yield significantly higher overall performance. [ABSTRACT FROM AUTHOR]

In this paper, we propose a scalable multicast protection scheme based on a dual-homing architecture where each destination host is connected to two edge routers. Under such an architecture, there are two paths from the source of a multicast session to each destination host, which provides a certain level of protection for the data traffic from the source to the destination host. The protection level varies from 0 percent to 100 percent against a single link failure, depending on the number of shared links between these two paths. The major advantage of the proposed scheme lies in its scalability due to the fact that the protection is provided by constructing a dual-homing architecture at the access network while keeping the routing protocols in the core network unchanged. The selection of dual edge routers plays an important role in enhancing the protection level. Two problems arise for the proposed dual-homing partial multicast protection scheme. One is to calculate the survivability from the source to any pair of edge routers. The other is to assign a pair of edge routers for each destination host such that the total survivability is maximized for the multicast session subject to the port number constraint of each edge router. We propose an optimal algorithm to solve the first problem. We prove the decision version of the second problem is NP-complete and propose two heuristic algorithms to solve it. Simulation results show that the proposed heuristic algorithms achieve performance close to the calculated lower bound. [ABSTRACT FROM AUTHOR]

The K-level Sigma-Delta (ΣΔ) scheme with step size δ is introduced as a technique for quantizing finite frame expansions for Rd. Error estimates for various quantized frame expansions are derived, and, in particular, it is shown that ΣΔ quantization of a unit-norm finite frame expansion in Rd achieves approximation error ∥x - ...∥ ≤ δd/2N (σ(F, p) + 1) where N is the frame size, and the frame variation σ(F, p) is a quantity which reflects the dependence of the ΣΔ scheme on the frame. Here ∥ · ∥ is the d-dimensional Euclidean 2-norm. Lower bounds and refined upper bounds are derived for certain specific cases. As a direct consequence of these error bounds one is able to bound the mean squared error (MSE) by an order of 1/N². When dealing with sufficiently redundant frame expansions, this represents a significant improvement over classical pulse-code modulation (PCM) quantization, which only has MSE of order 1/N under certain nonrigorous statistical assumptions. ΣΔ also achieves the optimal MSE order for PCM with consistent reconstruction. [ABSTRACT FROM AUTHOR]

We investigate the maximum increase in number of phrases that results from changing k consecutive symbols in a string x having length n parsed using an LZ'77-like algorithm. We consider a class of compression algorithms that partition a sequence into a collection y of nonoverlapping, variable-length phrases and encode them. Each phrase either is a singleton or matches a substring that starts to its left. We show that changing a single symbol of x in position i can yield an expansion that is of order O(n - i)2/3 as (n - i) → ∞. Our lower bound requires an alphabet size of O(n - i)1/3. We also show that changing k consecutive symbols starting from position i can yield an expansion having a similar but somewhat more involved form. The paper contains both analytically derived upper and lower bounds, and algorithms for numerically computing tighter bounds. While deriving the bounds, we provide a detailed analysis of how expansion can arise when changing consecutive symbols. This problem is motivated by management policies for computer systems, such as the IBM Memory eXpansion Technology (MXT) or the IBM iSeries compressed disks, that use LZ'77-like coding on small compression units, such as 1-4 kbyte, and store the compressed data in memory or on disk tracks. Here, when a change of a portion of the compression unit occurs, for example, an L2 cache line, or a 512-byte disk sector, the data is recompressed and potentially stored in a different location. Knowing the maximum expansion, rather than the average expansion, is an important factor for designing policies for allocation and management of memory or disk space. [ABSTRACT FROM AUTHOR]

The article suggests a new approach for multimethod implementation in C++. Several programming languages allow for multimethods, but C++ semantics do not. The proposed approach is based on recursive deferred dispatching. The multimethod implementation in C++ is discussed. The approach offers advantages that includes using a conventional multimethod syntax, it provides strong compile-time type safety and it decreases compilation time and ensures acceptable usability in real-world projects.

Abstract: The CMS collaboration is undertaking a big effort to define the analysis model and to develop software tools with the purpose of analysing several millions of simulated and real data events by a large number of people in many geographically distributed sites. From the computing point of view, one of the most complex issues when doing remote analysis is the data discovery and access. Some software tools were developed in order to move data, make them available to the full international community and validate them for the subsequent analysis. The batch analysis processing is performed with workload management tools developed on purpose, which are mainly responsible for the job preparation and the job submission. The job monitoring and the output management are implemented as the last part of the analysis chain. Grid tools provided by the LCG project are evaluated to gain access to the data and the resources by providing a user friendly interface to the physicists submitting the analysis jobs. An overview of the current implementation and of the interactions between the previous components of the CMS analysis system is presented in this work. [Copyright &y& Elsevier]

The article discusses model-driven engineering (MDE) technologies offering a new approach to cover the inability of third-generation technologies and to facilitate the complexities of platforms and express domain concepts effectively. Efforts in the past, like the computer-aided software engineering which focused in improving software methods and tools, elevated the level of abstraction used to develop software. To improve the MDE technologies, there must be a combination of a domain-specific modeling languages and transformation engines and generators.

The article discusses ways to identify and capture early aspects in requirements and architecture activities related to computer softwares. Early aspects are concerns that crosscut an artifact's dominant decomposition or base modules derived from the dominant separation-of-concerns criterion, in the early stages of the software life cycle. Identifying and managing early aspects helps in improving modularity in the requirements and architecture design and to detect conflicting concerns early, thus resolving trade-offs. Besides, identifying aspects at one stage provides benefits downstream. Knowledge of requirements-level aspects helps architects in designing a better systems. Similarly, knowing architecture-level aspects helps produce a better implementation. Early aspects can measure development activities and many find their way into the code as traditional implementation aspects. Identifying early aspects across phases can increase the consistency of requirements and architecture designs with each other and provides a rationale and traceability for aspects across life-cycle activities. INSET: Dominant Decomposition in Early Software Development..

An understanding of how software is employed in the field can yield many opportunities for quality improvements. Profiling released software can provide such an understanding. However, profiling released software is difficult due to the potentially large number of deployed sites that must be profiled, the transparency requirements at a user's site, and the remote data collection and deployment management process. Researchers have recently proposed various approaches to tap into the opportunities offered by profiling deployed systems and overcome those challenges. Initial studies have illustrated the application of these approaches and have shown their feasibility. Still, the proposed approaches, and the tradeoffs between overhead, accuracy, and potential benefits for the testing activity have been barely quantified. This paper aims to overcome those limitations. Our analysis of 1,200 user sessions on a 155 KLOC deployed system substantiates the ability of field data to support test suite improvements, assesses the efficiency of profiling techniques for released software, and the effectiveness of testing efforts that leverage profiled field data. [ABSTRACT FROM AUTHOR]

Advance knowledge of which files in the next release of a large software system are most likely to contain the largest numbers of faults can be a very valuable asset. To accomplish this, a negative binomial regression model has been developed and used to predict the expected number of faults in each file of the next release of a system. The predictions are based on the code of the file in the current release, and fault and modification history of the file from previous releases. The model has been applied to two large industrial systems, one with a history of 17 consecutive quarterly releases over 4 years, and the other with nine releases over 2 years. The predictions were quite accurate: For each release of the two systems, the 20 percent of the files with the highest predicted number of faults contained between 71 percent and 92 percent of the faults that were actually detected, with the overall average being 83 percent. The same model was also used to predict which files of the first system were likely to have the highest fault densities (faults per KLOC). In this case, the 20 percent of the files with the highest predicted fault densities contained an average of 62 percent of the system's detected faults. However, the identified files contained a much smaller percentage of the code mass than the files selected to maximize the numbers of faults. The model was also used to make predictions from a much smaller input set that only contained fault data from integration testing and later. The prediction was again very accurate, identifying files that contained from 71 percent to 93 percent of the faults, with the average being 84 percent. Finally, a highly simplified version of the predictor selected files containing, on average, 73 percent and 74 percent of the faults for the two systems. [ABSTRACT FROM AUTHOR]

The article discusses about the computer software design. In this article, the author casts the software engineering process into the FBS framework. In the FBS framework, eight processes link a set of five elements. The framework aims to analyze how engineers design— that is, the processes and intermediate artifacts that are produced. A significant gap exists between analysis in software, which maps to synthesis in FBS, and analysis in other engineering disciplines, which one could call static software analysis— the techniques and tools one can apply to the design models and code to derive some of their properties, correctness included, without having to finish the code and run it. Evaluation is the assessment of the gap between expected behaviors and observed behaviors. Evaluation consists mostly of analyzing test results and static software analysis results, and partly of reviews and inspections. It corresponds to RUP's test discipline and some project management activities.

Symmetry reduction techniques exploit symmetries that occur during the execution of a system in order to minimize its state space for efficient verification of temporal logic properties. This paper presents a framework for concisely defining and evaluating symmetry reductions currently used in software model checking, involving heap objects and processes. An on-the-fly state space exploration algorithm combining both techniques will also be presented. Second, the relation between symmetry and partial-order reductions is investigated, showing how one’s strengths can be used to compensate for the other’s weaknesses. The symmetry reductions presented here were implemented in the dSPIN model-checking tool. We also performed a number of experiments that show significant progress in reducing the cost of finite-state software verification. [ABSTRACT FROM AUTHOR]

Several studies have revealed the fact that nearly two-thirds of all software process improvement (SPI) efforts have failed or have at least fallen short of expectations. Literature and practice have shown that commitment to SPI at all organizational levels is essential for the success of any SPI endeavor. A research model for studying the existence, development and interplay of SPI-related commitment is introduced in this paper. This study suggests that software organizations operate through strategic, operational and personal commitment nets. These nets consist of actors, drivers, concerns, actions, commitment, and outcomes. The commitment nets model is applied in a study of four industrial SPI initiatives. The results from two of these cases are reported here. The results show that SPI is driven through the formation and reformation of commitment nets. The contents of strategic, operational and personal commitment nets are laid out and implications are discussed. [ABSTRACT FROM AUTHOR]

In this paper the authors discuss approaches to the automation of software development in use during the past 20 years for trunk business systems, in particular categorized reusable components, the center of this method's technology. First an outline of the software in question, the development environments, and approaches to automation is given. With respect to the major automation methods, the structure of methods for categorized reusable components, a structural element, and the design of skeletons for batch programming are described. This approach uses (1) input and output component groups, (2) program skeleton groups, and (3) data processing groups for which detailed processes have been turned into components, all in a mutually independent fashion as categorized reusable components for the software to be generated. Then these components are adjusted and a program is generated by combining them together using tools. By making the components independent in this fashion, this approach has the capacity to create X*Y*Z structures overall even with only X, Y, and Z components each. In addition, the 24 skeletons developed during this research are demonstrated to cover 90% of large-scale trunk systems, and the top 10 skeletons over 70%. © 2002 Wiley Periodicals, Inc. Electron Comm Jpn Pt 2, 85(6): 50–66, 2002; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/ecjb.10057 [ABSTRACT FROM AUTHOR]

Large and complex real-time systems can benefit significantly from a component-based development approach where new systems are constructed by composing reusable, documented and previously tested concurrent objects. However, reusing objects which execute under real-time constraints is problematic because application specific time and synchronization constraints are often embedded in the internals of these objects. The tight coupling of functionality and real-time constraints makes objects interdependent, and as a result difficult to reuse in another system. We propose a model which facilitates separate and modular specification of real-time constraints, and show how separation of real-time constraints and functional behavior is possible. We present our ideas using the Actor model to represent untimed objects, and the Real-time Synchronizers language to express real-time and synchronization constraints. We discuss specific mechanisms by which Real-time Synchronizers can govern the interaction and execution of untimed objects. We treat our model formally, and succinctly define what effect real-time constraints have on a set of concurrent objects. We briefly discuss how a middleware scheduling and event-dispatching service can use the synchronizers to execute the system. [ABSTRACT FROM AUTHOR]

An object based formal method for the development of real-time systems, called ATOM, is presented. The method is an integration of the real-time formal technique TAM (Temporal Agent Model) with an industry-strength structured methodology known as HRT-HOOD. ATOM is a systematic formal approach based on the refinement calculus. Within ATOM, a formal specification (or abstract description statement) contains Interval Temporal Logic (ITL) description of the timing, functional, and communication behavior of the proposed real-time system. This formal specification can be analyzed and then refined into concrete statements through successive applications of sound refinement laws. Both abstract and concrete statements are allowed to freely intermix. The semantics of the concrete statements in ATOM are defined denotationally in specification-oriented style using ITL. [ABSTRACT FROM AUTHOR]

The article announces the summer and fall conferences of the Institute of Electrical and Electronics Engineers (IEEE) Computer Society. A conference on computer vision and pattern recognition will be held on June 17-22, 2006 in New York. The 15th International Conference on Parallel Architectures and Compilation Techniques will be held on September 16-20, 2006 in Seattle, Washington. The 10th IEEE International Symposium on Wearable Computers to be participated by researchers, product vendors, and fashion designers will be held on October 11-14, 2006 in Montreux, Switzerland.

Charles Severance visits the Living Computer Museum in Seattle, Washington, to get back to his programming roots. The Web extra at https://youtu.be/ZHU4nzIsaIM goes behind the scenes of the author's recent visit to the Living Computer Museum. In the second Web extra at https://youtu.be/lnlL7cEJqtY, author Charles Severance provides an audio recording of his Computing Conversations column. [ABSTRACT FROM PUBLISHER]

The article presents suggestions on the problems to look for in computer software design and discusses the need to start solving these problems before they get out of control. The term refactoring is used to mean the improvement of the design of existing code in order to avoid heat death, which occurs when the design fails to the point where starting over is cheaper than continuing. The article also offers the steps followed by the author in rafactoring code, including the identifying an aspect of the design, recognizing ways to improve the design, and applying small changes in small steps.

The article talks about how to gain professional advancement from open source software development. A professional can benefit from an open source software by fixing and improving open source documents. Furthermore, he can also join open source projects in order to impress and interact with highly respected professionals. The professional can also gain by behaving like a system administrator who selects, configures, connects, and tunes subsystems into a robust and efficient larger part. In such a way, he gets rid of the typical classroom or corporate development setting.