Trace-level reuse

Trace-level reuse is based on the observation that some traces (dynamic sequences of instructions) are frequently repeated during the execution of a program, and in many cases, the instructions that make up such traces have the same source operand values. The execution of such traces will obviously produce the same outcome and thus, their execution can be skipped if the processor records the outcome of previous executions. This paper presents an analysis of the performance potential of trace-level reuse and discusses a preliminary realistic implementation. Like instruction-level reuse, trace-level reuse can improve performance by decreasing resource contention and the latency of some instructions. However, we show that trace-level reuse is more effective than instruction-level reuse because the former can avoid fetching the instructions of reused traces. This has two important benefits: it reduces the fetch bandwidth requirements, and it increases the effective instruction window size since these instructions do not occupy window entries. Moreover, trace-level reuse can compute all at once the result of a chain of dependent instructions, which may allow the processor to avoid the serialization caused by data dependences and thus, to potentially exceed the dataflow limit.Peer ReviewedPostprint (published version

MERLiN: Mixture Effect Recovery in Linear Networks

Causal inference concerns the identification of cause-effect relationships between variables, e.g. establishing whether a stimulus affects activity in a certain brain region. The observed variables themselves often do not constitute meaningful causal variables, however, and linear combinations need to be considered. In electroencephalographic studies, for example, one is not interested in establishing cause-effect relationships between electrode signals (the observed variables), but rather between cortical signals (the causal variables) which can be recovered as linear combinations of electrode signals. We introduce MERLiN (Mixture Effect Recovery in Linear Networks), a family of causal inference algorithms that implement a novel means of constructing causal variables from non-causal variables. We demonstrate through application to EEG data how the basic MERLiN algorithm can be extended for application to different (neuroimaging) data modalities. Given an observed linear mixture, the algorithms can recover a causal variable that is a linear effect of another given variable. That is, MERLiN allows us to recover a cortical signal that is affected by activity in a certain brain region, while not being a direct effect of the stimulus. The Python/Matlab implementation for all presented algorithms is available on https://github.com/sweichwald/MERLi

Simulations of Galactic Cosmic Ray Impacts on the Herschel/PACS bolometer Arrays with Geant4 Code

The effects of the in-flight behaviour of the bolometer arrays of the Herschel/PACS instrument under impacts of Galactic cosmic rays are explored. This instrument is part of the ESA-Herschel payload, which will be launched at the end of 2008 and will operate at the Lagrangian L2 point of the Sun-Earth system. We find that the components external to the detectors (the spacecraft, the cryostat, the PACS box, collectively referred to as the `shield') are the major source of secondary events affecting the detector behaviour. The impacts deposit energy on the bolometer chips and influence the behaviour of nearby pixels. 25% of hits affect the adjacent pixels. The energy deposited raises the bolometer temperature by a factor ranging from 1 to 6 percent of the nominal value. We discuss the effects on the observations and compare simulations with laboratory tests.Comment: Experimental Astronomy, 2008, in pres

Integer linear programming vs. graph-based methods in code generation

A common characterictic of many applications is that they are aimed at the high-volume consumer market, which is extremely cost-sensitive. However many of them impose stringent performance demands on the underlying system. Therefore the code generation must take into account the restrictions and features given by the target architecture while satisfying these performance demands. High-level language compilers often are unable to generate code meeting these requirements. One reason is the phase coupling problem between instruction scheduling and register allocation. Many compilers perform these tasks separately with each phase ignorant of the require- ments of the other. Commonly, each task is accomplished by using heuristic methods. As the goals of the two phases often conflict, whichever phase is performed first imposes constraints on the other, sometimes producing inefficient code. Integer linear programming (ILP) provides an integrated approach to the combined instruction scheduling and register allocation problem. This way, optimal solutions can be found - albeit at the cost of high compilation times. In our experiments, we considered as target processor the 32-bit DSP ADSP-2106x. We have examined two different ILP formulations and compared them with conventional approaches including list scheduling and the critical path method. Moreover, we have investigated approximations based on the ILP formulations; this way, compilation time can be reduced considerably while still producing near-optimal results. From the results of our implementation, we have concluded that integrating ILP formulations in conventional global algorithms is a promising method for generating high-quality code

Ultrafast manipulation of mirror domain walls in a charge density wave

Domain walls (DWs) are singularities in an ordered medium that often host exotic phenomena such as charge ordering, insulator-metal transition, or superconductivity. The ability to locally write and erase DWs is highly desirable, as it allows one to design material functionality by patterning DWs in specific configurations. We demonstrate such capability at room temperature in a charge density wave (CDW), a macroscopic condensate of electrons and phonons, in ultrathin 1T-TaS$_2$. A single femtosecond light pulse is shown to locally inject or remove mirror DWs in the CDW condensate, with probabilities tunable by pulse energy and temperature. Using time-resolved electron diffraction, we are able to simultaneously track anti-synchronized CDW amplitude oscillations from both the lattice and the condensate, where photo-injected DWs lead to a red-shifted frequency. Our demonstration of reversible DW manipulation may pave new ways for engineering correlated material systems with light