Equations’ Derivations In The Three-Dimensional Super-Voxel Calculations

Model-Based Iterative Reconstruction (MBIR) is a widely-explored fully 3D Computed Tomography (CT) image reconstruction technique that has a large impact on the image re- construction community. The slow computation speed for MBIR, however, is a bottleneck for scientific advancements in fields that use imaging, such as materials. A recently proposed algorithm, Non-Uniform Parallel Super-Voxel (NU-PSV), utilizes the concept of Three-Dimensional Super-Voxel (3DSV) and Block-Transposed Buffer (BTB) [1]. Experiments in the past show that the NU- PSV algorithm significantly improves the computation speed for MBIR by regularizing data access pattern, reducing cache misses, enabling more parallelism and speeding up algorithmic convergence. This technical report serves as an auxiliary appendix to publication [1]. In this technical report, we demonstrate the theoretical calculations related to a BTB

07361 Abstracts Collection -- Programming Models for Ubiquitous Parallelism

From 02.09. to 07.09.2007, the Dagstuhl Seminar 07361 ``Programming Models for Ubiquitous Parallelism\u27\u27 was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available

Extracting Source Level Program Similarities from Dynamic Behavior

The vast majority of work on comparing program similarities to detect software piracy either assumes the availability of the program source code (e.g., Moss) or performs a complicated source program transformation to embed carefully designed signatures, or software watermarks, into the binary code. In this paper, we propose a new approach to detecting program similarities that requires neither the availability of the program source nor complicated compile-time watermarking techniques. Furthermore, in contrast to the alternatives, our framework is resistant to standard attacks such as code obfuscation. Our approach exploits the observation that the sequence of system calls performed by a program execution provides a strong signature of the program semantics or functionality, thereby using the inherent properties of a program to identify it. By statistically analyzing sequences of system calls, the relative similarities and differences of program regions can be automatically determined. We have developed a framework that automatically extracts system call sequences, computes the similarities between two binaries via statistical analysis, and maps dynamically similar regions onto textually similar source files. We present several case studies showing the applicability of our framework in pinpointing pirated segments. Our experimental study also shows that directly comparing the binary files of the programs without considering their dynamic behavior is ineffective, and demonstrates strong consistency between the output of our new framework and that of Moss

Energieprijzen en emissiehandel

Elektriciteitsbedrijven maken windfall profi ts door gratis verkregen CO2-emissierechten. Deze windfall profi ts wil de Europese Commissie elimineren door de rechten te veilen. Dat elektriciteitsbedrijven windfall profi ts incasseren is echter economisch gezien geen probleem. Het gebruik van de gratis verstrekte emissierechten brengt immers kosten met zich mee, namelijk de alternatieve kosten (opportunity costs), verbonden aan het afzien van de verkoop van de rechten. Windfall profi ts vormen echter wel een politiek probleem, omdat aandeelhouders er rijker van worden. Veilen lost dat weliswaar op, maar introduceert ook nieuwe politieke problemen, bijvoorbeeld rond de verdeling van de opbrengsten en de concurrentie met bedrijven buiten het emissiehandelssysteem

Artemis: Practical Runtime Monitoring of Applications for Errors

A number of hardware and software techniques have been proposed to detect dynamic program behaviors that may indicate a bug in a program. Because these techniques suffer from high overheads they are useful in finding bugs in programs before they are released, but are significantly less useful in finding the much harder to detect bugs in long-running programs – the bugs that are the most difficult to find using traditional techniques. In this paper we propose the Artemis compiler-based instrumentation framework that complements many pre-existing runtime monitoring techniques, yielding an average asymptotic lower bound on overhead of 11% on the seven SPEC benchmarks tested

Automatic Parallelization: An Overview of Fundamental Compiler Techniques

Compiling for parallelism is a longstanding topic of compiler research. This book describes the fundamental principles of compiling "regular" numerical programs for parallelism. We begin with an explanation of analyses that allow a compiler to understand the interaction of data reads and writes in different statements and loop iterations during program execution. These analyses include dependence analysis, use-def analysis and pointer analysis. Next, we describe how the results of these analyses are used to enable transformations that make loops more amenable to parallelization, an

The dependence analysis and synchronization of parallel programs

The optimization of programs with explicit--i.e. user specified--parallelism requires the computation of the data dependence relation if optimizations performed by the compiler are to preserve sequential consistency. Shasha and Snir investigated the problem for straight-line code with data accesses performed on scalars. We extend their results to programs with sequential loops and cobegin or doall loop parallelism and data accesses performed on arrays. The array subscript information is used to increase the accuracy of the test in a way analogous to the data dependence tests for sequential programs.Once data dependences have been identified synchronization can be used to enforce the orderings specified by the data dependence. The automatic generation of synchronization, and the optimization of synchronization, by a compiler is investigated. Experimental results comparing the effectiveness of different optimization techniques are presented.U of I OnlyETDs are only available to UIUC Users without author permissio

Compiler Infrastructure

This special issue presents a number of papers that discuss the design of compiler infrastructures and their use in research and education projects. Early work described in these papers was presented at the “Cetus Users and Compiler Infrastructure Workshop,” held in conjunction with the International Conference on Parallel Architectures and Compilation Techniques, PACT’2011, in Galveston Texas, on October 10, 2011. The focus on the Cetus compiler is evident in the present papers as well. An attempt was made, however, to cover other infrastructure platforms as well. To this end, papers in the special issue also discuss the LLVM, OpenUH, and Rose platforms. These special issue papers have all been reviewed according to the journal’s high-quality standards for publication. The availability of advanced compiler infrastructures is of critical importance. It enables the implementation of a new program analysis, optimization, or transformation pass in the context of a complete translation platform that can handle realistic applications and thus evaluate the new pass quantitatively. As different research projects have different needs, more than a single compiler infrastructure is needed. It is not the goal of the special issue to advertise one best infrastructure. Rather, the reader can learn about features of different platforms and identify the one that is most useful for their research plan. The included papers pursue this aim as follows: The first article, by Bae et al., provides an overview of the Cetus compiler infrastructure. The second paper, by Yi Yang and Huiyang Zou, describes an optimizing compiler for GPGPU architectures that is built on the Cetus infrastructure. Next, Gabriel Rodríguez et al., compare two infrastructures, LLVM and Cetus, by using them in a project to create a compiler that provides fault tolerance for message-passing applications. Amin Sarvestani et al. have created a tool for idiom recognition in digital signal processing applications. They describe the use of the Cetus infrastructure for that purpose. Barbara Chapman et al. present the OpenHP compiler infrastructure and its use in research and education projects. Finally, Xipeng Shen et al. describe the use of the Cetus and Rose infrastructures in the creation of an auto-tuning system that adapts compiler optimizations for GPUs based on characteristics of the program input

A standard Java array package for technical computing

copyrighted if accepted for publication. It has been issued as a Research Report for early dissemination of its contents. In view of the transfer of copyright to the outside publisher, its distribution outside of IBM prior to publication should be limited to peer communications and specific requests. After outside publication, requests should be filled only by reprints or legally obtained copies of the article (e.g., payment of royalties). Copies may be requested from IBM T. J. Watson Research Cente

Introducing Parallel Programming in Undergraduate Curriculum

Abstract — This paper summarizes our experiences and findings in teaching the concepts of parallel computing in two undergraduate programming courses and an undergraduate hardware design course. The first is a junior-senior level elective course Object-Oriented Programming using C++ and Java. The second is a sophomore-level required course on Advanced C Programming. The third course, Introduction to Digital System Design, is also a sophomore-level required course. We will describe how parallel concepts have been integrated in the courses, the assessments, and the results