yusuke1997/dblp-id-title huggingface dataset:
From Loop Fusion to Kernel Fusion: A Domain-Specific Approach to Locality Optimization
A Compiler for Sound Floating-Point Computations using Affine Arithmetic
Software Transactional Memory for GPU Architectures
Whose Baseline Compiler is it Anyway?
Improving 64-Bit Java IPF Performance by Compressing Heap References
Data provenance tracking for concurrent programs
Automated locality optimization based on the reuse distance of string operations
Custom Data Layout for Memory Parallelism
Profiling k-Iteration Paths: A Generalization of the Ball-Larus Profiling Algorithm
Fourth IEEE/ACM International Symposium on Code Generation and Optimization (CGO 2006), 26-29 March 2006, New York, New York, USA
A Cross-Architectural Interface for Code Cache Manipulation
Adaptive Mapping and Parameter Selection Scheme to Improve Automatic Code Generation for GPUs
Athos - A Model Driven Approach to Describe and Solve Optimisation Problems: An Application to the Vehicle Routing Problem with Time Windows
ELFies: Executable Region Checkpoints for Performance Analysis and Simulation
On-demand dynamic summary-based points-to analysis
Retargetable and Reconfigurable Software Dynamic Translation
Pertinent path profiling: Tracking interactions among relevant statements
Fast Polynomial Evaluation for Correctly Rounded Elementary Functions using the RLIBM Approach
Taming hardware event samples for FDO compilation
Scenario Based Optimization: A Framework for Statically Enabling Online Optimizations
Tiramisu: A Polyhedral Compiler for Expressing Fast and Portable Code
Efficient Execution of Graph Algorithms on CPU with SIMD Extensions
Characterizing and enhancing global memory data coalescing on GPUs
Sixth International Symposium on Code Generation and Optimization (CGO 2008), April 5-9, 2008, Boston, MA, USA
Ispike: A Post-link Optimizer for the Intel®Itanium®Architecture
FinePar: irregularity-aware fine-grained workload partitioning on integrated architectures
r3d3: Optimized Query Compilation on GPUs
Sentinel PRE: Hoisting beyond Exception Dependency with Dynamic Deoptimization
Unleashing the Low-Precision Computation Potential of Tensor Cores on GPUs
Probabilistic Predicate-Aware Modulo Scheduling
SIMD parallelization of applications that traverse irregular data structures
Qiwu: Exploiting Ciphertext-Level SIMD Parallelism in Homomorphic Encryption Programs
Introducing the pseudorandom value generator selection in the compilation toolchain
Proceedings of the 2017 International Symposium on Code Generation and Optimization, CGO 2017, Austin, TX, USA, February 4-8, 2017
Compiler Optimizations to Reduce Security Overhead
Highly scalable distributed dataflow analysis
Automatic Generation of Debug Headers through BlackBox Equivalence Checking
Single-Dimension Software Pipelining for Multi-Dimensional Loops
Profile-guided automated software diversity
Automatic Feature Generation for Machine Learning Based Optimizing Compilation
Runtime asynchronous fault tolerance via speculation
The MLIR Transform Dialect: Your Compiler Is More Powerful Than You Think
BuildIt: A Type-Based Multi-stage Programming Framework for Code Generation in C++
Reality-Based Optimization
Parallel associative reductions in halide
Unified Compilation for Lossless Compression and Sparse Computing
Dynamically managed data for CPU-GPU architectures
OptiWISE: Combining Sampling and Instrumentation for Granular CPI Analysis
Loop transformations leveraging hardware prefetching
Collecting and Exploiting High-Accuracy Call Graph Profiles in Virtual Machines
A black-box approach to energy-aware scheduling on integrated CPU-GPU systems
Deriving parametric multi-way recursive divide-and-conquer dynamic programming algorithms using polyhedral compilers
Design, Implementation and Evaluation of Adaptive Recompilation with On-Stack Replacement
Automatic Horizontal Fusion for GPU Kernels
Evolution of a Stream Transformation DSL
Hybrid Java compilation and optimization for digital TV software platform
F3M: Fast Focused Function Merging
Dynamic buffer overflow detection for GPGPUs
Look-ahead SLP: auto-vectorization in the presence of commutative operations
Formally verifying a compiler: Why? How? How far?
Instruction Scheduling for the GPU on the GPU
A Dynamically Tuned Sorting Library
Vapor SIMD: Auto-vectorize once, run everywhere
Effective Adaptive Computing Environment Management via Dynamic Optimization
Automatic parallelization of simulink applications
Distill: Domain-Specific Compilation for Cognitive Models
On the platform specificity of STM instrumentation mechanisms
Compiling for niceness: mitigating contention for QoS in warehouse scale computers
Recovering Container Class Types in C++ Binaries
Isla Vista Heap Sizing: Using Feedback to Avoid Paging
Simplifying Scalable Graph Processing with a Domain-Specific Language
Addressing Mode Selection
Detecting and Eliminating Potential Violations of Sequential Consistency for Concurrent C/C++ Programs
An Evaluation of Memory Sharing Performance for Heterogeneous Embedded SoCs with Many-Core Accelerators
StencilFlow: Mapping Large Stencil Programs to Distributed Spatial Computing Systems
PresCount: Effective Register Allocation for Bank Conflict Reduction
GraalNN: Context-Sensitive Static Profiling with Graph Neural Networks
DeltaPath: Precise and Scalable Calling Context Encoding
Selecting Software Phase Markers with Code Structure Analysis
Pipelined Execution of Critical Sections Using Software-Controlled Caching in Network Processors
Automated programmable control and parameterization of compiler optimizations
Parallel-stage decoupled software pipelining
Synthesizing benchmarks for predictive modeling
Flow-sensitive pointer analysis for millions of lines of code
Removing redundancy via exception check motion
Program State Element Characterization
SySTeC: A Symmetric Sparse Tensor Compiler
International Symposium on Code Generation and Optimization - Front Cover
Multi-layer optimizations for end-to-end data analytics
Branch prediction and the performance of interpreters: don't trust folklore
Preliminary results for neuroevolutionary optimization phase order generation for static compilation
Report from the Artifact Evaluation Committee
CSOD: Context-Sensitive Overflow Detection
Defensive loop tiling for shared cache
Proceedings of the 13th Annual IEEE/ACM International Symposium on Code Generation and Optimization, CGO 2015, San Francisco, CA, USA, February 07 - 11, 2015
Loop Rolling for Code Size Reduction
Optimizing occupancy and ILP on the GPU using a combinatorial approach
Parallelism by design: data analysis with sawzall
Runtime dependence computation and execution of loops on heterogeneous systems
Code Synthesis for Sparse Tensor Format Conversion and Optimization
Runtime automatic speculative parallelization
1st IEEE / ACM International Symposium on Code Generation and Optimization (CGO 2003), 23-26 March 2003, San Francisco, CA, USA
Translating CUDA to OpenCL for Hardware Generation using Neural Machine Translation
Variable-Sized Blocks for Locality-Aware SpMV
A performance-optimizing compiler for cyber-physical digital microfluidic biochips
Optimizations to Prevent Cache Penalties for the Intel ® Itanium 2 Processor
Software Pipelined Execution of Stream Programs on GPUs
METRIC: Tracking Down Inefficiencies in the Memory Hierarchy via Binary Rewriting
Lightweight fault detection in parallelized programs
Janitizer: Rethinking Binary Tools for Practical and Comprehensive Security
CUDAAdvisor: LLVM-based runtime profiling for modern GPUs
Efficient compilation of fine-grained SPMD-threaded programs for multicore CPUs
Exhaustive Optimization Phase Order Space Exploration
Compiler-Managed Software-based Redundant Multi-Threading for Transient Fault Detection
Compiling for EDGE Architectures
HQEMU: a multi-threaded and retargetable dynamic binary translator on multicores
A Basic Linear Algebra Compiler
Automatic data placement into GPU on-chip memory resources
Alchemist: A Transparent Dependence Distance Profiling Infrastructure
Locality aware concurrent start for stencil applications
Vectron: A Dynamic Programming Auto-vectorization Framework
Java JNI Bridge: A Framework for Mixed Native ISA Execution
Data Layout and Data Representation Optimizations to Reduce Data Movement Keynote
LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation
Building Approximate Calling Context from Partial Call Traces
SGXElide: enabling enclave code secrecy via self-modification
Using graph-based program characterization for predictive modeling
Exploiting Narrow Accelerators with Data-Centric Subgraph Mapping
Q#: Enabling Scalable Quantum Computing and Development with a High-level DSL
Scan detection and parallelization in "inherently sequential" nested loop programs
Statistically regulating program behavior via mainstream computing
Portable and Transparent Host-Device Communication Optimization for GPGPU Environments
Cross-Input Learning and Discriminative Prediction in Evolvable Virtual Machines
Program optimization space pruning for a multithreaded gpu
Compile-Time Concurrent Marking Write Barrier Removal
Large program trace analysis and compression with ZDDs
PreFix: Optimizing the Performance of Heap-Intensive Applications
A trace-based Java JIT compiler retrofitted from a method-based compiler
A graph-based higher-order intermediate representation
Industrial Application of Domain Specific Languages Combined with Formal Techniques
Towards automatic significance analysis for approximate computing
VHC: Quickly Building an Optimizer for Complex Embedded Architectures
Boosting the Performance of Multi-Solver IFDS Algorithms with Flow-Sensitivity Optimizations
A Compiler-Guided Approach for Reducing Disk Power Consumption by Exploiting Disk Access Locality
Ecmas: Efficient Circuit Mapping and Scheduling for Surface Code
Exploring Code Cache Eviction Granularities in Dynamic Optimization Systems
Efficient nursery sizing for managed languages on multi-core processors with shared caches
Coloring-based coalescing for graph coloring register allocation
Estimating the Empirical Cost Function of Routines with Dynamic Workloads
BlackBox: lightweight security monitoring for COTS binaries
BEC: Bit-Level Static Analysis for Reliability against Soft Errors
Automatic Generation of Code Analysis Tools: The CastQL Approach
Comprehensive Accelerator-Dataflow Co-design Optimization for Convolutional Neural Networks
An Image Processing Language: External and Shallow/Deep Embeddings
Accelerating GPU Computing at Runtime with Binary Optimization
Automatic Generation of Warp-Level Primitives and Atomic Instructions for Fast and Portable Parallel Reduction on GPUs
On performance debugging of unnecessary lock contentions on multicore processors: a replay-based approach
Cheetah: detecting false sharing efficiently and effectively
Multi-platform Auto-vectorization
Validating optimizations of concurrent C/C++ programs
Are there Domain Specific Languages?
A General Compiler Framework for Speculative Optimizations Using Data Speculative Code Motion
Lightweight detection of cache conflicts
ANT-ACE: An FHE Compiler Framework for Automating Neural Network Inference
Understanding RDMA Behavior in NUMA Systems
gpucc: an open-source GPGPU compiler
YaskSite: Stencil Optimization Techniques Applied to Explicit ODE Methods on Modern Architectures
10th Annual IEEE/ACM International Symposium on Code Generation and Optimization, CGO 2012, San Jose, CA, USA, March 31 - April 04, 2012
Code optimization of parallel programs: evolutionary vs. revolutionary approaches
IPAS: intelligent protection against silent output corruption in scientific applications
The language, optimizer, and tools mess
Memory Safety Instrumentations in Practice: Usability, Performance, and Security Guarantees
Just-in-time value specialization
An Experience with Code-Size Optimization for Production iOS Mobile Applications
Dynamic interpretation for dynamic scripting languages
The Transmeta Code Morphing - Software: Using Speculation, Recovery, and Adaptive Retranslation to Address Real-Life Challenges
Aloe: verifying reliability of approximate programs in the presence of recovery mechanisms
Functional Programming, Glasgow, UK, 1995
Implementing Fudgets with Standard Widget Sets
Concurrent Data Manipulation in a Pure Functional Language
Functional Graph Algorithms with Depth-First Search (Preliminary Summary)
A Certain Loss of Identity
Time Profiling a Lazy Functional Compiler
Abstract Interpretation of Higher Order Functions Using Concrete Data Structures (Summary)
Deriving the Fast Fourier Algorithm by Calculation
The Technology Behind a Graphical User Interface for an Equational Reasoning Assistant
Chemical Reaction as a Computational Model
An Iterative Powerdomain Construction
Experiences with Clean I/O
Operational Theories of Improvement in Functional Languages (Extended Abstract)
A Parallel Functional Database on GRIP
Bidirectional Fold and Scan
Compile-Time Garbage Collection by Necessity Analysis
Dynamic Algebra for Calculating Algorithms
The Brisk Project: Concurrent and Distributed Functional Systems
Strictness Analysis in 4D
Abstract Interpretation vs. Type Inference A Topological Perspective
Generating a Pattern Matching Compiler by Partial Evaluation
Data Dependent Concurrency Control
Mechanized Reasoning about Functional Programs
Referentially Transparent Database Languages
Measuring the effectiveness of a simple strictness analyser
Sketching a Constructive Definition of 'mix'
Combining Single-Space and Two-Space Compacting Garbage Collectors
Avoiding Unnecessary Updates
High Level Specification of I/O in Functional Languages
Designing Data Structures
Generating Netlists from Executable Circuit Specifications
Improving Persistent Data Manipulation for Functional Languages
A Lazy, Self-optimizing Parallel Matrix Library
Abstract Interpretation of Polymorphic Functions
An Algorithmic and Semantic Approach to Debugging
Using XView/X11 from Miranda
LZW Text Compression in Haskell
Functional Binomial Queues
Experiments in Haskell - A Network Simulation Algorithm
Problems & Proposals for Time & Space Profiling of Functional Programs
Graphical User Interfaces for Haskell
Proceedings of the 1994 Glasgow Workshop on Functional Programming, Ayr, Scotland, UK, September 12-14, 1994
Unboxing using Specialisation
The Boom Hierarchy
Experiments with destructive updates in a lazy functional language (extended abstract)
Is Compile Time Garbage Collection Worth the Effort?
Making Functionality More General
Update Avoidance Analysis by Abstract Interpretation
Functional Programming, Proceedings of the 1989 Glasgow Workshop, 21-23 August 1989, Fraserburgh, Scotland, UK
Hope + on Flagship
Implementing Haskell Type Classes
A Logical Framework for Program Analysis
A Loop-Detecting Interpreter for Lazy Programs
Getting Your Wires Crossed
On the expressive power of Constructor Classes
Integrating Multithreading into the Spineless Tagless G-machine
Parsing Using Combinators
On Program Transformation in the Glasgow Haskell Compiler
Generalising Diverging Sequences of Rewrite Rules by Synthesising New Sorts
On the Comparative Evaluation of Parallel Languages and Systems: A Functional Note
Factoring an Adequacy Proof (Preliminary Report)
Projection-based Termination Analysis
Calculating lenient programs' performance
A New Method for Strictness Analysis on Non-Flat Domains
Towards a Purely Functional Debugger for Functional Programs
Geometrization for Interactive Software Development
Binding-time Improvement and Fold/Unfold Transformation
From Primitive Recursive Functions to Silicon through Relations
Combining Monads
Proceedings of the 1993 Glasgow Workshop on Functional Programming, Ayr, Scotland, UK, July 5-7, 1993
Solid Modelling in Haskell
PERs Generalise Projections for Strictness Analysis (Extended Abstract)
Describing Butterfly Networks in Ruby
A Semantics for Relational Programming
Type Reconstruction for SCI
Functional Programming, Glasgow 1992, Proceedings of the 1992 Glasgow Workshop on Functional Programming, Ayr, Scotland, UK, 6-8 July 1992
Implementation of a Non-Standard Interpretation System
Transformation in a Non-Strict Language: An Approach to Instantiation
On the Granularity of Divide-and-Conquer Parallelism
Improving Full Laziness
Uniqueness Typing in Natural Deduction Style
Extending Deforestation for First Order functional Programs
Techniques for Simplifying the Visualization of Graph Reduction
Algebraic Formula Manipulation in a Functional Language: A First Attempt
Requirements for a Functional Programming Environment
A Note on the Choice of Domains for Projection-Based Program Analysis
The nofib Benchmark Suite of Haskell Programs
A Novel Approach Towards Peephole Optimisations
Spiking Your Caches
Separating Interaction
External Function Calls in a Functional Language
Type Inference and Type Classes
Functional Programming with Relations
Expression Refinement: Deriving Bresenham's Algorithm
Normal-Order Reduction Using Scan Primitives
BWM: A Concrete Machine for Graph Reduction
Hazard Algebra and the Design of Asynchronous Automata
Analysing Functions by Projection-Based Backward Abstraction
Profiling Lazy Functional Programs
The Glasgow Haskell Compiler: A Retrospective
Improving Granularity in Parallel Functional Programs: A Graphical Winnowing System for Haskell
Compilation by Transformation in the Glasgow Haskell Compiler
Some Ideas On Parallel Functional Programming
Distributed Garbage Collection of Cyclic Structures
Fold-Unfold Transformations on State Monadic Interpreters
Towards a Declarative Language for Parallel and Concurrent Programming
Implementing Functional Languages on the Transputer
Programming Reactive Systems in Haskell
GRIT: Guy's RISC Implementation of the Three Instruction
A New Sharing Mechanism for the TIM
Experience of developing a cervical cytology scanning system using Gofer and Haskell
Profiling Parallel Functional Computations (Without Parallel Machines)
Strictness Analysis Using Hindley-Milner Type Inference
Programming with Constructor Classes (Preliminary Summary)
Differentiating Strictness
The Abstract interpretation of Higher-Order Functional Languages: From Properties to Abstract Domains (Technical Summary)
Simulating Multiprocessor Architectures for Compiled Graph-Reduction
Towards Binding-Time Improvement for Free
Dependent Sums Express Separation of Binding Times
Expressing and Reasoning About Non-Deterministic Functional Programs
Supporting Reasoning about Functional Programs: An Operational Approach
Heap Profiling of a Lazy Functional Compiler
A Functional Logic Language Based on Higher Order Narrowing
Analysing Heap Contents in a Graph Reduction Intermediate Language
Gerald: An Exceptional Lazy Functional Programming Language
A Note on Abstraction in Ruby
Deforestation for Higher-Order Functions
A Semantics for Locally Bottom-Avoiding Choice
A Tutorial on Co-induction and Functional Programming
Type Refinement in Ruby
Using Strictness in the STG Machine
Evaluation Annotations for Hope +
An Experiment using Term Rewriting Techniques for Concurrency
An Operational Model of Strictness Properties and Its Abstractions (Extended Abstract)
Imperative Effects from a Pure Functional Language
Vuillemin's Exact Real Arithmetic
Database Manipulation in Haskell 1.3
A Loop-Detecting Interpreter for Lazy, Higher-Order Programs
Formal Specification of Interconnection Networks
The Implementer's Dilemma: A Mathematical Model of Compile Time Garbage Collection
Lifetime analysis
ACTRESS: An Action Semantics Directed Compiler Generator (Summary)
Generating More Practical Compilers by Partial Evaluation
TIP in Haskell - another Exercise in Functional Programming
Formulating Haskell
Deterministic Concurrency
Efficient Type Inference Using Monads (Summary)
The aim is laziness in a data-parallel language
Evaluation Order Analysis for Lazy Data Structures
A framework for optimising abstract data types
Compiling Laziness by Partial Evaluation
Local Speculative Evaluation for Distributed Graph Reduction
Picture: A Simple Structured Graphics Model
Towards Relating Forwards and Backwards Analyses
Functional Compilation from the Standard ML Core Language to Lambda Calculus
A Case Study in Parallel Program Derivation: the Heat Equation Algorithm
Using Types to Parse Natural Language
Proceedings of the 1990 Glasgow Workshop on Functional Programming, Ullapool, Scotland, UK, August 13-15, 1990
Debugging by Dataflow - Summary
Backwards Strictness Analysis: Proved and Improved
Implementing Projection-based Strictness Analysis
Functional Programming, Glasgow 1991, Proceedings of the 1991 Glasgow Workshop on Functional Programming, Portree, Isle of Skye, UK, 12-14 August 1991
Type-Checked Message-Passing between Functional Processes
Solving recursive domain equations by term rewriting
Abstract Interpretation of Term Graph Rewriting Systems
Automatic Discourse Parsing of Arabic Text: Building Discourse Structure of Text
Complex Disfluencies Processing in Spontaneous Arabic Speech
Disfluent-to-Fluent Tunisian Dialect Speech Translation with Fine-Tuning Pre-trained Language Models
Deep Learning Approach to Identify and Classify Arabic Verbal Multi-word Expressions
Word Alignment Applied on English-Arabic Parallel Corpus
Advancements in Machine Learning and Natural Language Processing: Innovations and Applications - 3rd International Conference on Language Processing and Knowledge Management (LPKM'2024), Sfax, Tunisia, 3-5 June 2024
Typology of Event Data Imperfections
Sentiment Classification Method for Identification of Influential Learners in Social Networks Communities
A Design Pattern-Based Approach for Analyzing MapReduce Applications
Word Sense Disambiguation of Arabic Language with Word Embeddings as Part of the Creation of a Historical Dictionary
Anti-pattern Based IoRT-Aware Business Process Structure Verification Approach
From Data to Decisions: An Ontology-Driven Method for Opinion Mining
A Rule-Based System for Translating Libyan Dialect Dual Forms to Modern Standard Arabic
Tunisian Normalized Pronunciation
LLMs for Cyberbullying Detection in Political Social Media
N-Class Language Model for Tunisian Dialect Automatic Speech Recognition System
SERTUS Dataset Collection from Spontaneous Environments
Towards a Software Requirements Change Classification using Support Vector Machine
CRF-based Arabic Opinion Summarization System
An Approach for a Temporal Arabic Question Answering System Based on the Construction of a Temporal Resource
Automatic Summarization: Towards a Revised Extract
An Agricultural Sentiment Dataset for Pest Control and Crop Diseases
Analyzing the Impact of Big Data in Mental Health
Corpus of the Algerian Dialect CDalg: Linguistic Rules of Decision
Towards a Maude-Based Approach for Formal Modeling Deep Neural Networks
Text Categorization Can Enhance Domain-Agnostic Stopword Extraction
Machine Learning Serving the School Orientation Process
Optical Character Recognition For Arabic Language Using Neural Network
Comparing Classical and Novel Techniques for Feature Selection: Toward a Machine Learning Method
BERT-Based Model for Sarcasm Detection in Arabic Texts
A Suggested XML Model of a Dictionary of Meanings to Help Create a Historical Dictionary for Arabic
Proceedings of the second Conference on Language Processing and Knowledge Management, Kerkennah (Sfax), Tunisia, October 17-18, 2018
TraffScOnto: Ontology for Traffic Management in the Context of Smart City Domain
Tunisian Arabic Understanding: Resources Analysis and Evaluation
Towards a Collaborative Method for Crisis Management
Arabic Sentiment Analysis: An Empirical Study of Machine Translation's Impact
Deep Learning Approach for Early Prediction of Depression on Social Network
Automatic Speech Recognition for Tunisian Dialect
Towards an Approach for Extending BPMN with Quality Dimension
Opinion Analysis Based on a Sentiment Lexical Ontology and Deep Learning Models: Tunisian Dialect Case
Assessing BERT Models for Arabic Named Entity Recognition in a Multi-dialectal Context
Author Profiling for Arabic Tweets based on n-grams
Normalized Orthography for Tunisian Arabic
Adapting Large Language Models to Biomedical Domain: A Survey of Techniques and Approaches
A Survey of Textual Event Extraction from Social Networks
Organization vs. Individual: Twitter User classification