Tagged articles
compiler optimization
41 articles · Page 1 of 1

21CTOOct 30, 2026 · Fundamentals
New Kbuild patches and AI-driven compiler optimizations have cut Linux kernel defconfig build times to ~15 seconds on a 128-core AMD EPYC server — a ~30% gain without RAM disks — while allmodconfig builds approach two minutes; future Zen 6 and PCIe 6.0 hardware could push standard builds under 10 seconds.
AI-assisted compilationAMD EPYCKbuild
0 likes · 11 min read

This article explains C pointers through four layers—C language semantics, compiler transformations, CPU execution, and memory mapping—covering pointer types, arithmetic, arrays vs pointers, dynamic allocation, embedded hardware access, and common errors like null and dangling pointers with assembly examples.
C pointersCPU architecturecommon pitfalls
0 likes · 64 min read

This article explains how missing volatile causes infinite loops when waiting for interrupt-set flags, demonstrates compiler optimization caching variables in registers, and clarifies volatile's limits in multi-core systems and atomicity guarantees.
Concurrencycompiler optimizationembedded C
0 likes · 11 min read

This article explains how reading compiler-generated assembly helps C++ developers verify optimizations like SIMD vectorization, function inlining, and memory layout efficiency, using tools like perf and Compiler Explorer to replace guesswork with evidence-based performance tuning.
AoS vs SoAC++Godbolt
0 likes · 10 min read

This article benchmarks DPDK lock-free queue modes for asynchronous logging in a high-concurrency NAT gateway, showing single-core throughput of ~800k logs/sec and multi-core SPSC design achieving 4.6M logs/sec, while analyzing compiler optimization impact and producer-consumer scaling behavior.
DPDKMPSCNAT gateway
0 likes · 9 min read

A single uint8_t write in an int8 quantization kernel caused a three‑fold slowdown because the C++ character‑type aliasing exemption forced the compiler to reload a scale factor on every iteration, illustrating how strict aliasing rules and TBAA affect performance.
C++aliasingcompiler optimization
0 likes · 20 min read

The article explains how the vtprotobuf library writes to a byte slice from the tail toward the head, eliminating bounds‑check instructions, and demonstrates this effect with simple functions, compiler diagnostics, and references to the Go compiler source.
GoProtobufbounds check elimination
0 likes · 5 min read

The article provides a concise walkthrough of Go 1.26’s most impactful changes—including a streamlined new(expr) syntax for pointers, self‑referencing generics, deeper compiler escape analysis, explicit inline directives, experimental SIMD and secret‑handling packages, and a goroutine‑leak profiling tool—illustrated with ready‑to‑run code snippets and practical tips for immediate adoption.
GenericsGoNew Features
0 likes · 8 min read


AntTechJan 14, 2026 · Artificial Intelligence
This article highlights two cutting‑edge works from Ant Group’s research team—HAWK, a fixed‑word key decomposition switching accelerator that overcomes hardware challenges for FHE, and FHEFusion, a compiler framework that introduces operator fusion to dramatically speed CKKS‑based DNN inference—showcasing their designs, optimizations, and experimental gains.
DNN inferenceFully Homomorphic EncryptionSecure AI
0 likes · 7 min read

This article explains the purpose of C's volatile keyword, how it influences compiler optimizations, its role in multithreaded scenarios, the distinction between visibility and atomicity, and why memory barriers or locks are preferred for proper synchronization.
C++ConcurrencyMultithreading
0 likes · 8 min read

This article explains C++ compiler optimization levels, compares -O2 and -O3, provides practical usage examples and best‑practice guidelines, and demonstrates performance gains with benchmark code, helping developers choose the right optimization flag for development and release builds.
C++O2build
0 likes · 10 min read

Understanding C’s volatile keyword is essential for embedded programming: it prevents compiler optimizations on variables that may change unexpectedly, such as hardware registers or signal‑handler flags, and clarifies common misconceptions about memory visibility, atomicity, and proper usage scenarios.
C++compiler optimizationembedded programming
0 likes · 9 min read

This article presents an overview of Kuaishou's system software team, detailing its core value, challenges, the "Four Horizontal Four Vertical" architecture, JVM innovations such as transparent coroutines and checkpointing, advanced compilation techniques, kernel isolation for cloud‑native workloads, and extensive performance‑boosting strategies that have dramatically improved resource utilization and stability.
JVMKernel Isolationcompiler optimization
0 likes · 15 min read

This article explains the importance of instruction scheduling for modern CPU pipelines, describes dependency types, distinguishes dynamic and static scheduling, outlines LLVM's multiple scheduling phases and algorithms, and introduces the underlying topological‑sort technique used to improve compiler performance.
Instruction SchedulingLLVMStatic Scheduling
0 likes · 10 min read

This article explains Go’s dead code elimination (DCE) optimization, demonstrates it with sample code, shows how to inspect compiled binaries using go tool nm, and discusses factors that affect DCE such as code complexity, compiler flags, and reflection, helping developers reduce binary size.
Binary SizeGocompiler optimization
0 likes · 6 min read

This article compares the infinite‑loop constructs for(;;) and while(1) in C, examining compiler optimizations, performance measurements on microcontrollers, coding style guidelines, and industry standards to determine if one form offers any real advantage over the other.
c-programmingcompiler optimizationembedded systems
0 likes · 7 min read


ITPUBMay 2, 2024 · Databases
This article explains how Profile‑Guided Optimization (PGO) can increase MySQL throughput by 30‑50% without changing application code, detailing the required compilation steps, necessary CMake flags, and real‑world benchmark results that demonstrate the performance gains and their limitations.
C++MySQLPGO
0 likes · 10 min read

The article details Baidu APP’s comprehensive compiler‑optimization strategy, including GCC‑Oz size reduction, Swift‑Osize with whole‑module optimization, link‑time optimization, symbol stripping, dead‑code removal, asset catalog compression, minimizing C++ virtual functions, slimming third‑party SDKs, dropping unused ARM architectures, Xcode 14 binary‑size tweaks, and eliminating built‑in Swift libraries by raising the minimum iOS version.
LTOSWIFTcode optimization
0 likes · 16 min read

This article details Baidu APP’s iOS package‑size optimization series, focusing on compiler tweaks (GCC, Swift, LTO, symbol stripping, dead‑code removal, asset catalog settings, C++ virtual‑function reduction, third‑party SDK slimming), instruction‑set pruning, Xcode‑14 improvements, and Swift dynamic‑library handling, together with concrete Xcode configuration steps and measured size gains.
LTOPackage Size OptimizationSWIFT
0 likes · 21 min read

This article explains the difference between unsigned and signed integer overflow in C, shows how overflow can lead to buffer overflows and security breaches, illustrates common pitfalls with code examples, discusses compiler optimizations that remove overflow checks, and provides reliable techniques for detecting and preventing integer overflow.
c-programmingcompiler optimizationinteger overflow
0 likes · 15 min read

The article explains how Huawei's BiSheng compiler enhances GaussDB performance through architecture‑level, module‑level, and function‑level optimizations such as inline expansion, instruction prefetch, auto‑vectorization, link‑time optimization, and feedback‑guided optimizations, and outlines future development plans.
BISHENGGaussDBInline
0 likes · 8 min read

This article explains the Strict Aliasing Rule, how compilers use Type‑Based Alias Analysis (TBAA) for optimization, demonstrates LLVM’s metadata‑based implementation, introduces the TypeSanitizer tool for detecting aliasing violations, and offers practical guidance to avoid common pitfalls in C/C++ code.
LLVMcompiler optimizationsanitizer
0 likes · 33 min read

This article examines why Baidu's super‑app needed a drastic reduction in its iOS package size, outlines the metrics that link bundle size to download conversion, compares the app‑size footprints of major domestic and overseas apps, and details the multi‑layered technical solutions—resource trimming, architecture safeguards, compiler tweaks, image compression, and code slimming—that together saved over 50 MB while preserving functionality.
app size optimizationcompiler optimizationiOS
0 likes · 16 min read

This article explains ByteDance's large‑scale adoption of profile‑guided optimization (PGO), covering its principles, instrumentation and sampling methods, the automated platform built for data collection and compilation, and the resulting performance gains across dozens of critical services.
ByteDancePGOcompiler optimization
0 likes · 12 min read

Modern C++ performance suffers when seemingly harmless abstractions—such as virtual functions, hidden copies, non‑trivial destructors, overused std::shared_ptr, type‑erasing wrappers, std::variant/optional, and std::async—prevent inlining and efficient memory use, while patterns like std::move on returns, hidden destructors in tail recursion, and branchy loops thwart NRVO, tail‑call, and auto‑vectorization optimizations.
C++NRVOSIMD vectorization
0 likes · 16 min read

This article examines the historical origin of the ++ and -- operators, explains why they were introduced, demonstrates that modern compilers no longer gain performance from them, and argues that functional‑style design, iterator‑based loops, and operator‑overloading concerns have led many contemporary languages to remove or deprecate these operators.
C++Programming Language DesignPython
0 likes · 25 min read

TypeScript 4.8 beta, released June 21 2022, adds Stage‑3 decorator groundwork, tighter strict‑null narrowing, more precise template‑literal inference, disables binding‑pattern inference, warns literal === comparisons, and boosts watch/incremental/build performance, while introducing breaking changes to lib.d.ts and JSDoc type imports.
Type NarrowingTypeScript 4.8breaking changes
0 likes · 10 min read

This article explains how memory allocation on the stack is faster than on the heap, demonstrates the process with assembly instructions, provides benchmark code comparing allocation speeds, discusses compiler optimizations, and outlines the differences, advantages, and pitfalls of stack and heap memory usage.
C++Heapcompiler optimization
0 likes · 9 min read

This article explores the evolution of the iOS main.m AutoreleasePool since Xcode 11, explains how Thread‑Local Storage and compiler optimizations like tail‑call elimination affect object lifetimes, and demonstrates practical code examples and assembly insights for developers seeking deeper memory‑management understanding.
AutoreleasePoolTail Call Eliminationcompiler optimization
0 likes · 14 min read


21CTOFeb 25, 2022 · Fundamentals
Elon Musk discusses the importance of clear error messages, praises Rust's compiler advances, and argues that for peak performance on dedicated hardware, a custom‑compiled C solution remains essential, while his companies also rely on C++ and Python.
C languageRustcompiler optimization
0 likes · 2 min read

This article explores how digital circuit concepts inspired by Claude Shannon relate to program control and data flow, demonstrating JavaScript optimization through abstract syntax trees, data flow graphs, control flow graphs, and the Node Sea technique with practical Arduino and code examples.
ASTControl Flow GraphData Flow Graph
0 likes · 13 min read

The article shows how profiling‑driven compiler and OS techniques—such as sampling and instrumentation PGO, BOLT code layout, AutoFDO pipelines, basic‑block reordering, partial inlining, branch and function reordering—can alleviate instruction‑cache and front‑end stalls in large C/C++ cloud workloads, delivering up to 18 % performance gains.
C++Performance AnalysisProfile Guided Optimization
0 likes · 16 min read

A developer recounts a five‑day debugging saga where a new lock‑free network queue caused intermittent core dumps, ultimately traced to differing GCC optimization behaviors, and shares practical lessons on bug attitude, reproduction, static analysis, and effective logging.
BackendLoggingcompiler optimization
0 likes · 11 min read

This article investigates Java's string concatenation behavior, demonstrating through two examples why some concatenations invoke StringBuilder while others are optimized by the compiler, and explains the underlying bytecode differences revealed by decompiling with javap.
JavaJavapString Concatenation
0 likes · 3 min read

This article explains how the JVM C1 compiler uses value numbering and global value numbering to merge identical computations, detailing hash calculation, ValueMapArray structures, control‑flow analysis, kill scenarios, and code transformation techniques for effective optimization.
Data Flow AnalysisGlobal Value NumberingJVM
0 likes · 12 min read

This article explains Java's explicit null checks, introduces the JVM's implicit null check mechanism via ImplicitNullCheckStub, and details how the C1 and C2 compilers perform null‑check elimination using data‑flow analysis and SSA, highlighting performance implications and optimization strategies.
C1C2Implicit Null Check
0 likes · 9 min read

This article examines why identical-looking string concatenations in Java sometimes use StringBuilder and other times are optimized away, showing bytecode differences, explaining compiler behavior, and summarizing the conditions that affect reference equality.
JVMString ConcatenationStringBuilder
0 likes · 4 min read


21CTOApr 5, 2020 · Fundamentals
The article recounts a real SAP project where a stray 20‑second wait statement crippled performance, then outlines five actionable principles—including setting clear goals, using profilers, enabling compiler optimizations, targeted code adjustments, and mandatory code reviews—to ensure optimization improves speed without sacrificing quality.
code optimizationcode reviewcompiler optimization
0 likes · 11 min read

This guide shares practical experience and step‑by‑step solutions for migrating C/C++ and other language projects from x86 servers to ARM64 TaiShan platforms, covering compilation differences, code adjustments, compiler options, and performance tuning to achieve stable and efficient execution.
C++Taishanarm64
0 likes · 12 min read

This article explains how Swift objects are created and destroyed, how method calls are implemented compared with Objective‑C, the memory layout of Swift classes, the role of virtual tables, the impact of compiler optimizations, and the feasibility of runtime method replacement, illustrated with extensive C‑style pseudocode examples.
Memory LayoutSWIFTcompiler optimization
0 likes · 34 min read

The article explains why a C++ program produces different outputs with and without the -O2 optimization flag, tracing the issue to strict aliasing violations caused by type‑punning pointer casts, and shows how disabling -fstrict-aliasing or using -fno‑strict‑aliasing resolves the problem.
C++GCCOptimization Flags
0 likes · 8 min read
