Contributing to Open Source Swift
Explore contributing to Open Source Swift: learn about Swift's components, required skills, and best practices for getting your first fix accepted. Gain insights into Swift's ecosystem and development process.
Compiling Ruby to Native Code with Sorbet & LLVM
Explore Stripe's innovative approach to compiling Ruby using Sorbet and LLVM, aimed at improving performance in large-scale applications without sacrificing feature development.
Toolchain Options in 2023 - What's New in Compilers and Libcs?
Explore recent advancements in compilers and C libraries, comparing alternatives to traditional GNU tools and discussing their advantages, drawbacks, and potential pitfalls for embedded systems.
Fuzzing with AFL
Explore fuzzing techniques with AFL, covering installation, workflow, optimization, and practical tips for effective application testing and vulnerability discovery.
BLASPhemy - Improving BLAS Handling in Enzyme.jl
Optimizing BLAS and Lapack routines for Enzyme.jl, improving performance and reliability in numerical computations and machine learning applications within the Julia ecosystem.
Rapid: Region-Based Pointer Disambiguation for Efficient Memory Optimization
Explore Rapid, a tool for efficient pointer disambiguation using region-based allocation. Learn about its performance benefits, low-overhead allocator, and improved dynamic checks for compiler optimizations.
SSA as Freyd Categories - Categorical Semantics for Compiler Design
Explore the connection between Static Single Assignment (SSA) and Freyd categories, examining their graphical syntax and applications in compiler design and optimization.
SpEQ: Translation of Sparse Codes Using Equivalences
Discover SpEQ, a strategy for detecting semantics in sparse codes and translating to high-performance libraries. Learn about its implementation, evaluation, and performance gains across various backends.
Automatic Promotion of Helper Functions to TCG Using LLVM
Explore automatic translation of C helper functions to optimized Tiny Code Generators for QEMU using LLVM. Learn about performance improvements and see an interactive demo of C to TCG mappings.
Compiler Options Hardening for C and C++
Explore compiler options to enhance C/C++ program security. Learn about memory-safety issues, mitigation techniques, and the OpenSSF Compiler Options Hardening Guide for informed decision-making.
LLVM Improvements for Better Verification
Explore LLVM enhancements that facilitate improved code verification, focusing on techniques and strategies for more robust software development.
Large Language Models for Compiler Optimization
Explore how large language models can enhance compiler optimization, focusing on a custom 7B parameter Transformer model that generates optimal compiler options for minimizing code size.
Writing a Compiler with LLVM
Explore LLVM's bytecode ecosystem for compiling high-level languages into a common representation. Learn its basics, inner workings, and application in MethodScript, with code examples.
Kernel Function Tracing in the Face of Compiler Optimization
Explore advanced kernel function tracing techniques and overcome challenges posed by compiler optimizations in Linux systems.
Trustworthy Runtime Verification via Bisimulation - Experience Report
Explore trustworthy runtime verification using bisimulation in the Copilot framework. Learn how CopilotVerifier generates correctness proofs for compiled monitors, enhancing safety-critical system assurance.
C++ Overload Inspector - A Tool for Analyzing and Profiling Overloaded Function Calls
Explore a tool for analyzing and profiling overloaded function calls in C++. Learn about fundamental overloading rules, tricky examples, and how to optimize compilation time using the open-source inspector.
BinaryBuilder 2: Return of the Compilers - JuliaCon 2024
Explore BinaryBuilder 2's redesign, addressing pain points and unlocking new capabilities for complex software projects, multiple compilers, and platforms in Julia package development.
LLVM in HPC: Enabling Performance Portability, Interoperability, and Novel Features - Part 2
Explore recent LLVM efforts for HPC: portable CUDA, debugging at scale, GPU execution of legacy codes, automatic differentiation, ML in compilers, and static information impact.
Bridging Domain Science and HPC with Julia
Explore Julia's potential in HPC, combining scientific ecosystem with high performance. Gain insights on its strengths, limitations, and notable international projects from an experienced user.
High Speed Query Execution with Accelerators and C++ - Lecture
Explore advanced techniques for accelerating big data analytics using C++ and custom hardware, combining metaprogramming and novel processor architectures for optimized query execution.
LLVM Optimization Remarks - Helping the Compiler Generate Better Code
Explore LLVM optimization remarks to enhance code performance. Learn to decipher compiler logs, identify missed optimizations, and leverage tools like opt-viewer for actionable insights.