bluuebunny/crossref_metadata_2025_split huggingface dataset:
Management of Next-Generation NAND Flash to Achieve Enterprise-Level Endurance and Latency Targets
Authors: Pletka Roman , Koltsidas Ioannis , Ioannou Nikolas , Tomić Saša , Papandreou Nikolaos , Parnell Thomas , Pozidis Haralampos , Fry Aaron , Fisher Tim 
Published: December 2018

Despite its widespread use in consumer devices and enterprise storage systems, NAND flash faces a growing number of challenges. While technology advances have helped to increase the storage density and reduce costs, they have also led to reduced endurance and larger block variations, which cannot be compensated solely by stronger ECC or read-retry schemes but have to be addressed holistically.
Our goal is to enable low-cost NAND flash in enterprise storage for cost efficiency. We present novel flash-management approaches that reduce write amplification, achieve better wear leveling, and enhance endurance without sacrificing performance. We introduce block calibration, a technique to determine optimal read-threshold voltage levels that minimize error rates, and novel garbage-collection as well as data-placement schemes that alleviate the effects of block health variability and show how these techniques complement one another and thereby achieve enterprise storage requirements.
By combining the proposed schemes, we improve endurance by up to 15× compared to the baseline endurance of NAND flash without using a stronger ECC scheme. The flash-management algorithms presented herein were designed and implemented in simulators, hardware test platforms, and eventually in the flash controllers of production enterprise all-flash arrays. Their effectiveness has been validated across thousands of customer deployments since 2015.
HIL
Authors: Choi Jin-Yong , Nam Eyee Hyun , Seong Yoon Jae , Yoon Jin Hyuk , Lee Sookwan , Kim Hong Seok , Park Jeongsu , Woo Yeong-Jae , Lee Sheayun , Min Sang Lyul 
Published: December 2018

We present a framework called Hierarchically Interacting Logs (HIL) for constructing Flash Translation Layers (FTLs). The main goal of the HIL framework is to
heal
the Achilles
heel
—the crash recovery—of FTLs (hence, its name). Nonetheless, the framework itself is general enough to encompass not only block-mapped and page-mapped FTLs but also many of their variants, including hybrid ones, because of its compositional nature.

Crash recovery within the HIL framework proceeds in two phases: structural recovery and functional recovery. During the structural recovery, residual effects due to program operations ongoing at the time of the crash are eliminated in an atomic manner using shadow paging. During the functional recovery, operations that would have been performed if there had been no crash are replayed in a redo-only fashion. Both phases operate in an idempotent manner, preventing repeated crashes during recovery from causing any additional problems.
We demonstrate the practicality of the proposed HIL framework by implementing a prototype and showing that its performance during normal execution and also during crash recovery is at least as good as those of state-of-the-art SSDs.
Towards Robust File System Checkers
Authors: Gatla Om Rameshwar , Zheng Mai , Hameed Muhammad , Dubeyko Viacheslav , Manzanares Adam , Blagojevic Filip , Guyot Cyril , Mateescu Robert 
Published: December 2018

File systems may become corrupted for many reasons despite various protection techniques. Therefore, most file systems come with a checker to recover the file system to a consistent state. However, existing checkers are commonly assumed to be able to complete the repair without interruption, which may not be true in practice. In this work, we demonstrate via fault injection experiments that checkers of widely used file systems (EXT4, XFS, BtrFS, and F2FS) may leave the file system in an uncorrectable state if the repair procedure is interrupted unexpectedly. To address the problem, we first fix the ordering issue in the undo logging of e2fsck and then build a general logging library (i.e., rfsck-lib) for strengthening checkers. To demonstrate the practicality, we integrate rfsck-lib with existing checkers and create two new checkers: rfsck-ext, a robust checker for Ext-family file systems, and rfsck-xfs, a robust checker for XFS file systems, both of which require only tens of lines of modification to the original versions. Both rfsck-ext and rfsck-xfs are resilient to faults in our experiments. Also, both checkers incur reasonable performance overhead (i.e., up to 12%) compared to the original unreliable versions. Moreover, rfsck-ext outperforms the patched e2fsck by up to nine times while achieving the same level of robustness.
Hop, Skip, & Jump
Authors: Wang Kunshan , Blackburn Stephen M. , Hosking Antony L. , Norrish Michael 
Published: December 2018

On-stack replacement (OSR) is a performance-critical technology for many languages, especially dynamic languages. Conventional wisdom, apparent in JavaScript engines such as V8 and SpiderMonkey, is that OSR must be implemented in a low-level (i.e., in assembly) and language-specific way.
This paper presents an OSR abstraction based on Swapstack, materialized as the API for a low-level virtual machine, and shows how the abstraction of resumption protocols facilitates an elegant implementation of this API on real hardware. Using an experimental JavaScript implementation, we demonstrate that this API enables the language implementation to perform OSR without the need to deal with machine-level details. We also show that the API itself is implementable on concrete hardware. This work helps crystallize OSR abstractions and, by providing a reusable implementation, brings OSR within reach for more language implementers.
BLeak: automatically debugging memory leaks in web applications
Authors: Vilk John , Berger Emery D. 
Published: December 2018

Despite the presence of garbage collection in managed languages like JavaScript, memory leaks remain a serious problem. In the context of web applications, these leaks are especially pervasive and difficult to debug. Web application memory leaks can take many forms, including failing to dispose of unneeded event listeners, repeatedly injecting iframes and CSS files, and failing to call cleanup routines in third-party libraries. Leaks degrade responsiveness by increasing GC frequency and overhead, and can even lead to browser tab crashes by exhausting available memory. Because previous leak detection approaches designed for conventional C, C++ or Java applications are ineffective in the browser environment, tracking down leaks currently requires intensive manual effort by web developers.
This paper introduces BLeak (Browser Leak debugger), the first system for automatically debugging memory leaks in web applications. BLeak's algorithms leverage the observation that in modern web applications, users often repeatedly return to the same (approximate) visual state (e.g., the inbox view in Gmail). Sustained growth between round trips is a strong indicator of a memory leak. To use BLeak, a developer writes a short script (17-73 LOC on our benchmarks) to drive a web application in round trips to the same visual state. BLeak then automatically generates a list of leaks found along with their root causes, ranked by return on investment. Guided by BLeak, we identify and fix over 50 memory leaks in popular libraries and apps including Airbnb, AngularJS, Google Analytics, Google Maps SDK, and jQuery. BLeak's median precision is 100%; fixing the leaks it identifies reduces heap growth by an average of 94%, saving from 0.5 MB to 8 MB per round trip. We believe BLeak's approach to be broadly applicable beyond web applications, including to GUI applications on desktop and mobile platforms.
Calling-to-reference context translation via constraint-guided CFL-reachability
Authors: Cai Cheng , Zhang Qirun , Zuo Zhiqiang , Nguyen Khanh , Xu Guoqing , Su Zhendong 
Published: December 2018

A calling context is an important piece of information used widely to help developers understand program executions (e.g., for debugging). While calling contexts offer useful control information, information regarding data involved in a bug (e.g., what data structure holds a leaking object), in many cases, can bring developers closer to the bug's root cause. Such data information, often exhibited as heap reference paths, has already been needed by many tools.
The only way for a dynamic analysis to record complete reference paths is to perform heap dumping, which incurs huge runtime overhead and renders the analysis impractical. This paper presents a novel static analysis that can precisely infer, from a calling context of a method that contains a use (e.g., read or write) of an object, the heap reference paths leading to the object at the time the use occurs. Since calling context recording is much less expensive, our technique provides benefits for all dynamic techniques that need heap information, significantly reducing their overhead.
iReplayer: in-situ and identical record-and-replay for multithreaded applications
Authors: Liu Hongyu , Silvestro Sam , Wang Wei , Tian Chen , Liu Tongping 
Published: December 2018

Reproducing executions of multithreaded programs is very challenging due to many intrinsic and external non-deterministic factors. Existing RnR systems achieve significant progress in terms of performance overhead, but none targets the in-situ setting, in which replay occurs within the same process as the recording process. Also, most existing work cannot achieve identical replay, which may prevent the reproduction of some errors.
This paper presents iReplayer, which aims to identically replay multithreaded programs in the original process (under the "in-situ" setting). The novel in-situ and identical replay of iReplayer makes it more likely to reproduce errors, and allows it to directly employ debugging mechanisms (e.g. watchpoints) to aid failure diagnosis. Currently, iReplayer only incurs 3% performance overhead on average, which allows it to be always enabled in the production environment. iReplayer enables a range of possibilities, and this paper presents three examples: two automatic tools for detecting buffer overflows and use-after-free bugs, and one interactive debugging tool that is integrated with GDB.
Bayonet: probabilistic inference for networks
Authors: Gehr Timon , Misailovic Sasa , Tsankov Petar , Vanbever Laurent , Wiesmann Pascal , Vechev Martin 
Published: December 2018

Network operators often need to ensure that important probabilistic properties are met, such as that the probability of network congestion is below a certain threshold. Ensuring such properties is challenging and requires both a suitable language for probabilistic networks and an automated procedure for answering probabilistic inference queries.
We present Bayonet, a novel approach that consists of: (i) a probabilistic network programming language and (ii) a system that performs probabilistic inference on Bayonet programs. The key insight behind Bayonet is to phrase the problem of probabilistic network reasoning as inference in existing probabilistic languages. As a result, Bayonet directly leverages existing probabilistic inference systems and offers a flexible and expressive interface to operators.
We present a detailed evaluation of Bayonet on common network scenarios, such as network congestion, reliability of packet delivery, and others. Our results indicate that Bayonet can express such practical scenarios and answer queries for realistic topology sizes (with up to 30 nodes).
Advanced automata-based algorithms for program termination checking
Authors: Chen Yu-Fang , Heizmann Matthias , Lengál Ondřej , Li Yong , Tsai Ming-Hsien , Turrini Andrea , Zhang Lijun 
Published: December 2018

In 2014, Heizmann et al. proposed a novel framework for program termination analysis. The analysis starts with a termination proof of a sample path. The path is generalized to a Büchi automaton (BA) whose language (by construction) represents a set of terminating paths. All these paths can be safely removed from the program. The removal of paths is done using automata difference, implemented via BA complementation and intersection. The analysis constructs in this way a set of BAs that jointly "cover" the behavior of the program, thus proving its termination. An implementation of the approach in Ultimate Automizer won the 1st place in the Termination category of SV-COMP 2017.
In this paper, we exploit advanced automata-based algorithms and propose several non-trivial improvements of the framework. To alleviate the complementation computation for BAs---one of the most expensive operations in the framework---, we propose a multi-stage generalization construction. We start with generalizations producing subclasses of BAs (such as deterministic BAs) for which efficient complementation algorithms are known, and proceed to more general classes only if necessary. Particularly, we focus on the quite expressive subclass of semideterministic BAs and provide an improved complementation algorithm for this class. Our experimental evaluation shows that the proposed approach significantly improves the power of termination checking within the Ultimate Automizer framework.
A general path-based representation for predicting program properties
Authors: Alon Uri , Zilberstein Meital , Levy Omer , Yahav Eran 
Published: December 2018

Predicting program properties such as names or expression types has a wide range of applications. It can ease the task of programming, and increase programmer productivity. A major challenge when learning from programs is
how to represent programs in a way that facilitates effective learning
.

We present a
general path-based representation
for learning from programs. Our representation is purely syntactic and extracted automatically. The main idea is to represent a program using paths in its abstract syntax tree (AST). This allows a learning model to leverage the structured nature of code rather than treating it as a flat sequence of tokens.

We show that this representation is general and can: (i) cover different prediction tasks, (ii) drive different learning algorithms (for both generative and discriminative models), and (iii) work across different programming languages.
We evaluate our approach on the tasks of predicting variable names, method names, and full types. We use our representation to drive both CRF-based and word2vec-based learning, for programs of four languages: JavaScript, Java, Python and C#. Our evaluation shows that our approach obtains better results than task-specific handcrafted representations across different tasks and programming languages.
To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries
Authors: Steindorfer Michael J. , Vinju Jurgen J. 
Published: December 2018

An immutable multi-map is a many-to-many map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in compilers, runtimes of programming languages, or in static analysis of object-oriented systems. Collection data structures are assumed to carefully balance execution time of operations with memory consumption characteristics and need to scale gracefully from a few elements to multiple gigabytes at least. When processing larger in-memory data sets the overhead of the data structure encoding itself becomes a memory usage bottleneck, dominating the overall performance.
In this paper we propose AXIOM, a novel hash-trie data structure that allows for a highly efficient and type-safe multi-map encoding by distinguishing inlined values of singleton sets from nested sets of multi-mappings. AXIOM strictly generalizes over previous hash-trie data structures by supporting the processing of fine-grained type-heterogeneous content on the implementation level (while API and language support for type-heterogeneity are not scope of this paper). We detail the design and optimizations of AXIOM and further compare it against state-of-the-art immutable maps and multi-maps in Java, Scala and Clojure. We isolate key differences using microbenchmarks and validate the resulting conclusions on a case study in static analysis. AXIOM reduces the key-value storage overhead by 1.87x; with specializing and inlining across collection boundaries it improves by 5.1x.
Genetic, Epigenetic, and Immunologic Profiling of MMR-Deficient Relapsed Glioblastoma
Authors: Indraccolo Stefano , Lombardi Giuseppe , Fassan Matteo , Pasqualini Lorenza , Giunco Silvia , Marcato Raffaella , Gasparini Alessandra , Candiotto Cinzia , Nalio Silvia , Fiduccia Pasquale , Fanelli Giuseppe Nicolò , Pambuku Ardi , Della Puppa Alessandro , D'Avella Domenico , Bonaldi Laura , Gardiman Marina Paola , Bertorelle Roberta , De Rossi Anita , Zagonel Vittorina 
Published: December 2018

Abstract

Purpose:
In-depth characterization of recurrent glioblastoma (rGBM) might contribute to a better understanding of the mechanisms behind tumor progression and enable rGBM treatment with targeted drugs.
Experimental Design: In this study, GBM samples were collected at diagnosis and recurrence from adult patients treated with Stupp protocol. Expression of mismatch repair (MMR) proteins was evaluated by IHC, followed by whole exome sequencing (WES) of tumor samples showing loss of MSH6 reactivity. Established genetic, epigenetic, and immunologic markers were assessed by standard methods and correlated with loss of MMR proteins and patient survival.

Results:
Expression of MMR proteins was partially or completely lost in 25.9% rGBM samples. Specifically, 12 samples showed partial or total MSH6 expression reduction. Conversely, 96.4% of GBM samples at diagnosis expressed MMR markers. WES disclosed lack of variants in MMR genes in primary samples, whereas two MSH6-negative rGBM samples shared a c.3438+1G&gt;A* splicing MSH6 variant with a potential loss of function effect. MSH6-negative rGBM specimens had high tumor mutational burden (TMB), but no microsatellite instability. In contrast, GBM samples with partial loss of MMR proteins disclosed low TMB. MMR-deficient rGBM showed significant telomere shortening and MGMT methylation and are characterized by highly heterogeneous MHC class I expression.

Conclusions:
Multilevel profiling of MMR-deficient rGBM uncovered hypermutated genotype uncoupled from enriched expression of immune-related markers. Assessment of MHC class I expression and TMB should be included in protocols aiming to identify rGBM patients potentially eligible for treatment with drugs targeting immune-checkpoint inhibitors.
MGMT Promoter Methylation Cutoff with Safety Margin for Selecting Glioblastoma Patients into Trials Omitting Temozolomide: A Pooled Analysis of Four Clinical Trials
Authors: Hegi Monika E. , Genbrugge Els , Gorlia Thierry , Stupp Roger , Gilbert Mark R. , Chinot Olivier L. , Nabors L. Burt , Jones Greg , Van Criekinge Wim , Straub Josef , Weller Michael 
Published: December 2018

Abstract

Purpose:
The methylation status of the O6-methylguanine DNA methyltransferase (MGMT) gene promoter is predictive for benefit from temozolomide in glioblastoma (GBM). A clinically optimized cutoff was sought allowing patient selection for therapy without temozolomide, while avoiding to withhold it from patients who may potentially benefit.
Experimental Design: Quantitative MGMT methylation-specific PCR data were obtained for newly diagnosed patients with GBM screened or treated with standard radiotherapy and temozolomide in four randomized trials. The pooled dataset was randomly split into a training and test dataset. The unsupervised cutoff was obtained at a 50% probability to be (un)methylated. ROC analysis identified an optimal cutoff supervised by overall survival (OS).

Results:
For 4,041 patients valid MGMT results were obtained, whereof 1,725 were randomized. The unsupervised cutoff in the training dataset was 1.27 (log2[1,000 × (MGMT+1)/ACTB]), separating unmethylated and methylated patients. The optimal supervised cutoff for unmethylated patients was −0.28 (AUC = 0.61), classifying “truly unmethylated” (≤−0.28) and “gray zone” patients (&gt;−0.28, ≤1.27), the latter comprising approximately 10% of cases. In contrast, for patients with MGMT methylation (&gt;1.27) more methylation was not related to better outcome. Both methylated and gray zone patients performed significantly better for OS than truly unmethylated patients [HR = 0.35, 95% confidence interval (CI), 0.27–0.45, P &lt; 0.0001; HR = 0.58, 95% CI, 0.43–0.78, P &lt; 0.001], validated in the test dataset. The MGMT assay was highly reproducible upon retesting of 218 paired samples (R2 = 0.94).

Conclusions:
Low MGMT methylation (gray zone) may confer some sensitivity to temozolomide treatment, hence the lower safety margin should be considered for selecting patients with unmethylated GBM into trials omitting temozolomide.
Intracellular Activation of Complement C3 Leads to PD-L1 Antibody Treatment Resistance by Modulating Tumor-Associated Macrophages
Authors: Zha Haoran , Wang Xinxin , Zhu Ying , Chen Diangang , Han Xiao , Yang Fei , Gao Jianbao , Hu Chunyan , Shu Chi , Feng Yi , Tan Yulong , Zhang Jinyu , Li Yongsheng , Wan Yisong Y. , Guo Bo , Zhu Bo 
Published: December 2018

Abstract
Complement aids in the construction of an immunosuppressive tumor microenvironment. Tumor cell–derived C3 has been previously reported, but whether and how it acts on antitumor immunity remains to be elucidated. Here, we describe a mechanism for tumor cell–derived C3 in suppressing antitumor immunity. Tumor cell–derived C3 was activated intracellularly, which results in generation of C3a. C3a modulated tumor-associated macrophages via C3a-C3aR-PI3Kγ signaling, thereby repressing antitumor immunity. Deletion of C3 in tumor cells that had high C3 expression enhanced efficacy of anti–PD-L1 treatment. Collectively, our results suggest tumor cell–derived C3 may be a useful target for cancer immunotherapy and that targeting C3 in tumor cells may enhance antitumor immunity.
An Antibody Designed to Improve Adoptive NK-Cell Therapy Inhibits Pancreatic Cancer Progression in a Murine Model
Authors: Lee Jaemin , Kang Tae Heung , Yoo Wonbeak , Choi Hyunji , Jo Seongyea , Kong Kyungsu , Lee Sang-Rae , Kim Sun-Uk , Kim Ji-Su , Cho Duck , Kim Janghwan , Kim Jeong-Yoon , Kwon Eun-Soo , Kim Seokho 
Published: December 2018

Abstract
Natural killer (NK) cells are primary immune cells that target cancer cells and can be used as a therapeutic agent against pancreatic cancer. Despite the usefulness of NK cells, NK-cell therapy is limited by tumor cell inhibition of NK-cell homing to tumor sites, thereby preventing a sustained antitumor immune response. One approach to successful cancer immunotherapy is to increase trafficking of NK cells to tumor tissues. Here, we developed an antibody-based NK-cell–homing protein, named NK-cell–recruiting protein-conjugated antibody (NRP-body). The effect of NRP-body on infiltration of NK cells into primary and metastatic pancreatic cancer was evaluated in vitro and in murine pancreatic ductal adenocarcinoma models. The NRP-body increased NK-cell infiltration of tumors along a CXCL16 gradient (CXCL16 is cleaved from the NRP-body by furin expressed on the surface of pancreatic cancer cells). CXCL16 induced NK-cell infiltration by activating RhoA via the ERK signaling cascade. Administration of the NRP-body to pancreatic cancer model mice increased tumor tissue infiltration of transferred NK cells and reduced the tumor burden compared with that in controls. Overall survival of NRP-body–treated mice (even the metastasis models) was higher than that of mice receiving NK cells alone. In conclusion, increasing NK-cell infiltration into tumor tissues improved response to this cancer immunotherapy. The combination of an NRP-body with NK-cell therapy might be useful for treating pancreatic cancer.