bluuebunny/crossref_metadata_2025_split huggingface dataset:
Chlorophyll
Authors: Phothilimthana Phitchaya Mangpo , Jelvis Tikhon , Shah Rohin , Totla Nishant , Chasins Sarah , Bodik Rastislav 
Published: September 2014

We developed Chlorophyll, a synthesis-aided programming model and compiler for the GreenArrays GA144, an extremely minimalist low-power spatial architecture that requires partitioning the program into fragments of no more than 256 instructions and 64 words of data. This processor is 100-times more energy efficient than its competitors, but currently can only be programmed using a low-level stack-based language.
The Chlorophyll programming model allows programmers to provide human insight by specifying partial partitioning of data and computation. The Chlorophyll compiler relies on synthesis, sidestepping the need to develop classical optimizations, which may be challenging given the unusual architecture. To scale synthesis to real problems, we decompose the compilation into smaller synthesis subproblems---partitioning, layout, and code generation. We show that the synthesized programs are no more than 65% slower than highly optimized expert-written programs and are faster than programs produced by a heuristic, non-synthesizing version of our compiler.
A framework for enhancing data reuse via associative reordering
Authors: Stock Kevin , Kong Martin , Grosser Tobias , Pouchet Louis-Noël , Rastello Fabrice , Ramanujam J. , Sadayappan P. 
Published: September 2014

The freedom to reorder computations involving associative operators has been widely recognized and exploited in designing parallel algorithms and to a more limited extent in optimizing compilers.
In this paper, we develop a novel framework utilizing the associativity and commutativity of operations in regular loop computations to enhance register reuse. Stencils represent a particular class of important computations where the optimization framework can be applied to enhance performance. We show how stencil operations can be implemented to better exploit register reuse and reduce load/stores. We develop a multi-dimensional retiming formalism to characterize the space of valid implementations in conjunction with other program transformations. Experimental results demonstrate the effectiveness of the framework on a collection of high-order stencils.
Æminium
Authors: Stork Sven , Naden Karl , Sunshine Joshua , Mohr Manual , Fonseca Alcides , Marques Paulo , Aldrich Jonathan 
Published: September 2014

The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering considerations.
We conduct our study through the design of the concurrent-by-default ÆMINIUM programming language. ÆMINIUM leverages the permission flow of object and group permissions through the program to validate the program's correctness and to automatically infer a possible parallelization strategy via a dataflow graph. ÆMINIUM supports not only fork-join parallelism but more general dataflow patterns of parallelism.
In this paper we present a formal system, called μÆMINIUM, modeling the core concepts of ÆMINIUM. μÆMINIUM's static type system is based on Featherweight Java with ÆMINIUM-specific extensions. Besides checking for correctness ÆMINIUM's type system it also uses the permission flow to compute a potential parallel execution strategy for the program. μÆMINIUM's dynamic semantics use a concurrent-by-default evaluation approach. Along with the formal system we present its soundness proof.
We provide a full description of the implementation along with the description of various optimization techniques we used. We implemented ÆMINIUM as an extension of the Plaid programming language, which has first-class support for permissions built-in. The ÆMINIUM implementation and all case studies are publicly available under the General Public License.
We use various case studies to evaluate ÆMINIUM's applicability and to demonstrate that ÆMINIUM parallelized code has performance improvements compared to its sequential counterpart. We chose to use case studies from common domains or problems that are known to benefit from parallelization, to show that ÆMINIUM is powerful enough to encode them. We demonstrate through a webserver application, which evaluates ÆMINIUM's impact on latency-bound applications, that ÆMINIUM can achieve a 70% performance improvement over the sequential counterpart. In another case study we chose to implement a dictionary function to evaluate ÆMINIUM's capabilities to express essential data structures. Our evaluation demonstrates that ÆMINIUM can be used to express parallelism in such data-structures and that the performance benefits scale with the amount of annotation effort which is put into the implementation. We chose an integral computationally example to evaluate pure functional programming and computational intensive use cases. Our experiments show that ÆMINIUM is capable of extracting parallelism from functional code and achieving performance improvements up to the limits of Plaid's inherent performance bounds.
Overall, we hope that the work helps to advance concurrent programming in modern programming environments.
ASAC
Authors: Roy Pooja , Ray Rajarshi , Wang Chundong , Wong Weng Fai 
Published: September 2014

The approximation based programming paradigm is especially attractive for developing error-resilient applications, targeting low power embedded devices. It allows for program data to be computed and stored approximately for better energy efficiency. The duration of battery in the smartphones, tablets, etc. is generally more of a concern to users than an application's accuracy or fidelity beyond certain acceptable quality of service. Therefore, relaxing accuracy to improve energy efficiency is an attractive trade-off when permissible by the application's domain. Recent works suggest source code annotations and type qualifiers to facilitate safe approximate computation and data manipulation. It requires rewriting of programs or the availability of source codes for annotations. This may not be feasible as real-world applications tend to be large, with source code that is not readily available.
In this paper, we propose a novel sensitivity analysis that automatically generates annotations for programs for the purpose of approximate computing. Our framework, ASAC, extracts information about the sensitivity of the output with respect to program data. We show that the program output is sensitive to only a subset of program data that we deem critical, and hence must be precise. The rest of the data can be computed and stored approximately.We evaluated our analysis on a range of applications, and achieved a 86% accuracy compared to manual annotations by programmers. We validated our analysis by showing that the applications are within the acceptable QoS threshold if we approximate the non-critical data.
CASM
Authors: Lezuo Roland , Paulweber Philipp , Krall Andreas 
Published: September 2014

In this paper we present CASM, a language based on Abstract State Machines (ASM), and its optimizing compiler. ASM is a well-defined (formal) method based on algebraic concepts. A distinct feature of ASM is its combination of parallel and sequential execution semantics. This makes it an excellent choice to formally specify and verify micro-architectures. We present a compilation scheme and an implementation of a runtime system supporting efficient execution of ASM.
After introducing novel analysis techniques we present optimizations allowing us to eliminate many costly operations.
Benchmark results show that our baseline compiler is 2-3 magnitudes faster than other ASM implementations. The optimizations further increase the performance of the compiled programs up to 264%. The achieved performance allows our ASM implementation to be used with industry-size applications.
Cache-related preemption delay analysis for FIFO caches
Authors: Ballabriga Clément , Chong Lee Kee , Roychoudhury Abhik 
Published: September 2014

Hard real-time systems are typically composed of multiple tasks, subjected to timing constraints. To guarantee that these constraints will be respected, the Worst-Case Response Time (WCRT) of each task is needed. In the presence of systems supporting preemptible tasks, we need to take into account the time lost due to task preemption. A major part of this delay is the Cache-Related Preemption Delay (CRPD), which represents the penalties due to cache block evictions by preempting tasks. Previous works on CRPD have focused on caches with Least Recently used (LRU) replacement policy. However, for many real-world processors such as ARM9 or ARM11, the use of First-in-first-out (FIFO) cache replacement policy is common.
In this paper, we propose an approach to compute CRPD in the presence of instruction caches with FIFO replacement policy. We use the result of a FIFO instruction cache categorization analysis to account for single-task cache misses, and we model as an Integer Linear Programming (ILP) system the additional preemption-related cache misses. We study the effect of cache related timing anomalies, our work is the first to deal with the effect of timing anomalies in CRPD computation. We also present a WCRT computation method that takes advantage of the fact that our computed CRPD does not increase linearly with respect to the preemption count. We evaluated our method by computing the CRPD with realistic benchmarks (e.g. drone control application, robot controller application), under various cache configuration parameters. The experimentation shows that our method is able to compute tight CRPD bound for benchmark tasks.
Combinatorial spill code optimization and ultimate coalescing
Authors: Castañeda Lozano Roberto , Carlsson Mats , Hjort Blindell Gabriel , Schulte Christian 
Published: September 2014

This paper presents a novel combinatorial model that integrates global register allocation based on ultimate coalescing, spill code optimization, register packing, and multiple register banks with instruction scheduling (including VLIW). The model exploits alternative temporaries that hold the same value as a new concept for ultimate coalescing and spill code optimization.
The paper presents Unison as a code generator based on the model and advanced solving techniques using constraint programming. Thorough experiments using MediaBench and a processor (Hexagon) that are typical for embedded systems demonstrate that Unison: is robust and scalable; generates faster code than LLVM (up to 41% with a mean improvement of 7%); possibly generates optimal code (for 29% of the experiments); effortlessly supports different optimization criteria (code size on par with LLVM).
Unison is significant as it addresses the same aspects as traditional code generation algorithms, yet is based on a simple integrated model and robustly can generate optimal code.
How to compute worst-case execution time by optimization modulo theory and a clever encoding of program semantics
Authors: Henry Julien , Asavoae Mihail , Monniaux David , Maïza Claire 
Published: September 2014

In systems with hard real-time constraints, it is necessary to compute upper bounds on the worst-case execution time (WCET) of programs; the closer the bound to the real WCET, the better. This is especially the case of synchronous reactive control loops with a fixed clock; the WCET of the loop body must not exceed the clock period.
We compute the WCET (or at least a close upper bound thereof) as the solution of an optimization modulo theory problem that takes into account the semantics of the program, in contrast to other methods that compute the longest path whether or not it is feasible according to these semantics. Optimization modulo theory extends satisfiability modulo theory (SMT) to maximization problems.
Immediate encodings of WCET problems into SMT yield formulas intractable for all current production-grade solvers --- this is inherent to the DPLL(T) approach to SMT implemented in these solvers. By conjoining some appropriate "cuts" to these formulas, we considerably reduce the computation time of the SMT-solver.
We experimented our approach on a variety of control programs, using the OTAWA analyzer both as baseline and as underlying microarchitectural analysis for our analysis, and show notable improvement on the WCET bound on a variety of benchmarks and control programs.
em-SPADE
Authors: Chaudhary Sandeep , Fischmeister Sebastian , Tan Lin 
Published: September 2014

Traditional compilers ignore processor specifications, thousands of pages of which are available for modern processors. To bridge this gap, em-SPADE analyzes processor specifications and creates processor-specific rules to reduce low-level programming errors. This work shows the potential of automatically analyzing processor- and other hardware specifications to detect low-level programming errors at compile time.
em-SPADE is a compiler extension to automatically detect software bugs in low-level programs. From processor specifications, a preprocessor extracts target-specific rules such as register use and read-only or reserved registers. A special LLVM pass then uses these rules to detect incorrect register assignments. Our experiments with em-SPADE have correctly extracted 652 rules from 15 specifications and consequently found 20 bugs in ten software projects. The work is generalizable to other types of specifications and shows the clear prospects of using hardware specifications to enhance compilers.
Lightweight and block-level concurrent sweeping for javascript garbage collection
Authors: Kim Hongjune , Bak Seonmyeong , Lee Jaejin 
Published: September 2014

JavaScript is a dynamic-typed language originally developed for the purpose of giving dynamic client-side behaviors to web pages. It is mainly used in web application development and because of its popularity and rapid development style it is now also used in other types of applications. Increasing data processing requirements and growing usage in more resource-limited environments, such as mobile devices, has given demands for JavaScript implementations to handle memory more efficiently through garbage collection.
Since aggressive use of time consuming operations in garbage collection can slow down the JavaScript application, there is a trade-off relationship between the effectiveness and the execution time of garbage collection.
In this paper, we present a lightweight, block-level concurrent sweeping mechanism for a mark-and-sweep garbage collector. The sweeping process is detached to an additional thread to eagerly collect free memory blocks and recycle it. To minimize the overhead that comes from the synchronization between the mutator thread and the new sweeping thread, we have chosen a course grained block-level collecting scheme for sweeping. To avoid contention that comes from object destruction, we execute the object destruction phase concurrently with the foreground marking phase.
We have implemented our algorithm in JavaScript Core (JSC) engine embedded in the WebKit browser that uses a variant of mark-and-sweep algorithm to manage JavaScript objects. The original garbage collection implementation performs lazy sweeping that cannot reuse the free blocks. We evaluate our implementation on an ARM-based mobile system and show that memory utilization of the system is significantly improved without performance degradation.
Efficient resource placement in cloud computing and network applications
Authors: Rochman Yuval , Levy Hanoch , Brosh Eli 
Published: September 2014

We address the problem of resource placement in general networking applications, in particular cloud computing. We consider a large-scale service faced by regionally distributed demands for various resources. The service aims at placing the resources across regions to maximize profit, accounting for demand granting revenues minus resource placement costs. Cloud computing and online services, utilizing regional datacenters and facing the problem of where and how much to place various servers, naturally fall under this paradigm.
The main challenge posed by this setting is the need to deal with arbitrary multi-dimensional stochastic demands. We show that, despite the challenging stochastic combinatorial complexity, one can optimize the system operation using fairly efficient algorithms.
Network Modeling of TGFβ Signaling in Hepatocellular Carcinoma Epithelial-to-Mesenchymal Transition Reveals Joint Sonic Hedgehog and Wnt Pathway Activation
Authors: Steinway Steven Nathaniel , Zañudo Jorge G.T. , Ding Wei , Rountree Carl Bart , Feith David J. , Loughran Thomas P. , Albert Reka 
Published: September 2014

Abstract
Epithelial-to-mesenchymal transition (EMT) is a developmental process hijacked by cancer cells to leave the primary tumor site, invade surrounding tissue, and establish distant metastases. A hallmark of EMT is the loss of E-cadherin expression, and one major signal for the induction of EMT is TGFβ, which is dysregulated in up to 40% of hepatocellular carcinoma (HCC). We have constructed an EMT network of 70 nodes and 135 edges by integrating the signaling pathways involved in developmental EMT and known dysregulations in invasive HCC. We then used discrete dynamic modeling to understand the dynamics of the EMT network driven by TGFβ. Our network model recapitulates known dysregulations during the induction of EMT and predicts the activation of the Wnt and Sonic hedgehog (SHH) signaling pathways during this process. We show, across multiple murine (P2E and P2M) and human HCC cell lines (Huh7, PLC/PRF/5, HLE, and HLF), that the TGFβ signaling axis is a conserved driver of mesenchymal phenotype HCC and confirm that Wnt and SHH signaling are induced in these cell lines. Furthermore, we identify by network analysis eight regulatory feedback motifs that stabilize the EMT process and show that these motifs involve cross-talk among multiple major pathways. Our model will be useful in identifying potential therapeutic targets for the suppression of EMT, invasion, and metastasis in HCC. Cancer Res; 74(21); 5963–77. ©2014 AACR.
Targeting the Oncogenic MUC1-C Protein Inhibits Mutant EGFR-Mediated Signaling and Survival in Non–Small Cell Lung Cancer Cells
Authors: Kharbanda Akriti , Rajabi Hasan , Jin Caining , Tchaicha Jeremy , Kikuchi Eiki , Wong Kwok-Kin , Kufe Donald 
Published: September 2014

Abstract
Purpose: Non–small cell lung cancers (NSCLC) that express EGF receptor with activating mutations frequently develop resistance to EGFR kinase inhibitors. The mucin 1 (MUC1) heterodimeric protein is aberrantly overexpressed in NSCLC cells and confers a poor prognosis; however, the functional involvement of MUC1 in mutant EGFR signaling is not known.
Experimental Design: Targeting the oncogenic MUC1 C-terminal subunit (MUC1-C) in NSCLC cells harboring mutant EGFR was studied for effects on signaling, growth, clonogenic survival, and tumorigenicity.
Results: Stable silencing of MUC1-C in H1975/EGFR(L858R/T790M) cells resulted in downregulation of AKT signaling and inhibition of growth, colony formation, and tumorigenicity. Similar findings were obtained when MUC1-C was silenced in gefitinib-resistant PC9GR cells expressing EGFR(delE746_A750/T790M). The results further show that expression of a MUC1-C(CQC→AQA) mutant, which blocks MUC1-C homodimerization, suppresses EGFR(T790M), AKT and MEK→ERK activation, colony formation, and tumorigenicity. In concert with these results, treatment of H1975 and PC9GR cells with GO-203, a cell-penetrating peptide that blocks MUC1-C homodimerization, resulted in inhibition of EGFR, AKT, and MEK→ERK signaling and in loss of survival. Combination studies of GO-203 and afatinib, an irreversible inhibitor of EGFR, further demonstrate that these agents are synergistic in inhibiting growth of NSCLC cells harboring the activating EGFR(T790M) or EGFR(delE746-A750) mutants.
Conclusions: These findings indicate that targeting MUC1-C inhibits mutant EGFR signaling and survival, and thus represents a potential approach alone and in combination for the treatment of NSCLCs resistant to EGFR kinase inhibitors. Clin Cancer Res; 20(21); 5423–34. ©2014 AACR.
Lung Squamous Cell Carcinomas with Basaloid Histology Represent a Specific Molecular Entity
Authors: Brambilla Christian , Laffaire Julien , Lantuejoul Sylvie , Moro-Sibilot Denis , Mignotte Hélène , Arbib François , Toffart Anne-Claire , Petel Fabien , Hainaut Pierre , Rousseaux Sophie , Khochbin Saadi , de Reyniès Aurélien , Brambilla Elisabeth 
Published: September 2014

Abstract
Purpose: The basaloid carcinoma (pure) and the (mixed) basaloid variant of lung squamous cell carcinoma (SCC) have a dismal prognosis but their underlying specific molecular characteristics remain obscure and no therapy has proven to be efficient.
Experimental Design: To assess their molecular specificity among other lung SCCs we analyzed DNA copy number aberrations and mRNA expression pangenomic profiles of 93 SCCs, including 42 basaloid samples (24 pure, 18 mixed).
Results: Supervised analyses reveal that pure basaloid tumors display a specific mRNA expression profile, encoding factors controlling the cell cycle, transcription, chromatin, and splicing, with prevalent expression in germline and stem cells, while genes related to squamous differentiation are underexpressed. From this signature, we derived a 2-genes (SOX4, IVL) immunohistochemistry-based predictor that discriminated basaloid tumors (pure and mixed) from non-basaloid tumors with 94% accuracy in an independent series. The pure basaloid tumors are also distinguished through unsupervised analyses. Using a centroid-based predictor, the corresponding molecular subtype was found in 8 independent public datasets (n = 58/533), and was shown to be associated with a very poor survival as compared with other SCCs (adjusted HR = 2.45; P = 0.000001).
Conclusion: This study enlightens the heterogeneity of SCCs that can be subclassified in mRNA expression subtypes. This study demonstrates for the first time that basaloid SCCs constitute a distinct histomolecular entity, which justifies its recognition and distinction from non-basaloid SCCs. In addition, their characteristic molecular profile highlights their intrinsic resistance to cytotoxic chemotherapy and could serve as a guide for targeted therapies. Clin Cancer Res; 20(22); 5777–86. ©2014 AACR.