Search

Advances in DNA-sequencing technology have far outpaced Moore’s law, imposing significant challenges on the computationally intensive secondary analysis in the sequencing pipeline. An accelerator for seed extension, a critical and computationally intensive step in genome sequencing, is proposed. The accelerator, implementing a string-independent automata, consists of a triangular array of $25\times 2$ custom-designed processing elements. It performs 2.46 million reads per second (MRPS), achieving a $1581\times $ improvement in power efficiency and $165.5\times $ smaller silicon footprint compared to a system setting with dual-socket Xeon E5-2697 v3 server processors. [ABSTRACT FROM AUTHOR]

Memory persistency models enable maintaining recoverable data structures in persistent memories and prior work has proposed ISA-level persistency models. In addition to these models, we argue for extending language-level memory models to provide persistence semantics. We present a taxonomy of guarantees a language-level persistency model could provide and characterize their programmability and performance. [ABSTRACT FROM AUTHOR]

Recent efforts to standardize concurrency semantics for programming languages require programmers to explicitly annotate all memory accesses that can participate in a data race ("unsafe" accesses). This requirement allows the compiler and hardware to aggressively optimize unannotated accesses, which are assumed to be data-race-free ("safe" accesses), while still preserving the intuitive thread interleaving semantics known as sequential consistency (SC). However, unannotated data races are easy for programmers to accidentally introduce and difficult to detect, and thus the safety and correctness of programs can be significantly compromised. The authors argue instead for a safety-first approach, whereby the compiler and hardware treat every memory access as potentially unsafe unless it is proven otherwise. In this way, SC semantics is guaranteed for all programs, whether data-race-free or not. The authors show that the performance and design cost of this approach is insignificant in practice, because the majority of accesses can be proven safe through a simple static or dynamic analysis, and memory ordering constraints can be ignored for such accesses without violating SC. Together with their earlier work on an efficient SC-preserving compiler, their SC hardware provides end-to-end SC semantics at the language level with low overhead. [ABSTRACT FROM PUBLISHER]

The article discusses the proposed programmable hardware patching mechanisms to address processor design errors and its benefits. The proposed patching mechanisms are tested on AMD64 and Pentium 4 processors, which asserts that it can cover 78 percent of errors found in AMD64 processors and 69 percent of errors from Pentium 4. Among the benefits presented, the company avoids from expensive chip recall and suppress the damage in reputation, it avoids disabled functionality or poor performance, and allows manufacturers to save 10 weeks of design testing. The author asserts that the new mechanisms offer manufacturers a better way to handle errors, allows them to release hardware patches to fix errors, and provide an exciting environment.

The article presents information on an computer processor, Bugnet which helps the software developers to deterministically replay and debug an application while executing an computer program. The article author says that the difficult part of debugging is reproducing the bugs at a customer's site because it relys on core dumps which contain the final state of the system before the crash. The article authors' say that they propose the BugNet architecture to assist program developers to continuously record a program's execution as it runs. The Deterministic Replay Debugging technique helps to replay the exact same sequence of instructions that led up to the crash. The processor Bugnet continuously records a program's execution without interfering with the execution of the monitored program. The BugNet writes the logs to a fixed-sized buffer allocated in main memory so that software developers can then use these logs at the time of crash to deterministically replay the last part of execution as many times as required to fix the bug.