--- title: A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA... description: A comprehensive taxonomy of 19 GPU bug classes for CUDA verification, organized by impact type (Safety, Correctness, Performance) and GPU specificity... canonical: https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA Verification | daily.dev og:description: A comprehensive taxonomy of 19 GPU bug classes for CUDA verification, organized by impact type (Safety, Correctness, Performance) and GPU specificity... og:url: https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt og:image: https://api.daily.dev/og/posts/jSs2KpGpT.png og:image:alt: A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA Verification og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA Verification **[eunomia eBPF Blog](https://daily.dev/sources/eunomia)** · 50 min read · 0 upvotes · 0 comments ## Summary A comprehensive taxonomy of 19 GPU bug classes for CUDA verification, organized by impact type (Safety, Correctness, Performance) and GPU specificity (GPU-specific, GPU-amplified, CPU-shared). Each defect class is analyzed through verification scope (Extension-local, Combined, Host+Device) and assurance type (by-construction, static-sound, contract-based, etc.). Key findings: 14 of 19 bug classes can be addressed through Extension-local verification alone, validating the eBPF design philosophy of restricting extension capabilities. Only three classes fundamentally resist Extension-local verification: block-size dependence, launch config assumptions, and host-device async races. The taxonomy is motivated by the bpftime gpu_ext framework, which brings eBPF-style static verification guarantees to GPU kernels. Major bug classes covered include barrier divergence, warp-divergence races, insufficient atomic scope, uncoalesced memory access, shared-memory data races, and kernel non-termination, with concrete detection tools (GPUVerify, GKLEE, Compute Sanitizer, Simulee, iGUARD) and verification strategies for each. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What are the main categories of bugs in CUDA GPU programming and how are they classified? CUDA GPU bugs fall into 19 classes organized by impact type (Safety, Correctness, Performance) and GPU specificity (GPU-specific, GPU-amplified, CPU-shared). GPU-specific bugs include barrier divergence, invalid warp sync, insufficient atomic scope, warp-divergence races, uncoalesced memory access, and shared-memory data races. GPU-amplified bugs include atomic contention, non-barrier deadlocks, and kernel non-termination. CPU-shared bugs include global-memory data races, memory safety violations, and arithmetic errors. _Teams building or auditing CUDA kernels track emerging verification research and tooling on daily.dev._ ### How many CUDA GPU bug classes can be verified without inspecting the host kernel using Extension-local analysis? 14 of 19 GPU bug classes can be fully addressed through Extension-local verification, examining only the policy code without inspecting the host kernel. Three of these (#2 Invalid Warp Sync, #10 Missing Volatile/Fence, #15 Non-Barrier Deadlocks) can be eliminated by construction through language restrictions. Four others (#3, #5, #14, #17) initially appear to require Combined analysis but reduce to Extension-local through state isolation. _Developers designing GPU extension frameworks find the latest verification research on daily.dev._ ### What tools can detect barrier divergence bugs in CUDA kernels? Barrier divergence in CUDA kernels can be detected by GPUVerify (static verification proving divergence freedom via uniformity reasoning), Compute Sanitizer synccheck (runtime detection reporting 'divergent thread(s) in block'), and Simulee (evolutionary simulation-based bug finding in real-world code). Wu et al.'s empirical study explicitly classifies barrier divergence under improper synchronization as a CUDA-specific root cause. _CUDA developers staying ahead of GPU correctness tooling follow new releases and research on daily.dev._ ## Similar posts on daily.dev - [Why eBPF Verifier Errors Are Hard to Fix: The Diagnostic Gap](https://daily.dev/posts/why-ebpf-verifier-errors-are-hard-to-fix-the-diagnostic-gap-uxwhcropv) · eunomia eBPF Blog · 0 upvotes · 0 comments - [How we keep GPUs reliable across Databricks AI](https://daily.dev/posts/how-we-keep-gpus-reliable-across-databricks-ai-um3yzqfzg) · databricks · 0 upvotes · 0 comments - [How eBPF Empowers Developers to Observe Inside the Linux Kernel in a Safe and Unintrusive Way](https://daily.dev/posts/how-ebpf-empowers-developers-to-observe-inside-the-linux-kernel-in-a-safe-and-unintrusive-way-jhmpnwjer) · InfoQ · 0 upvotes · 0 comments - [Hardening eBPF for runtime security: Lessons from Datadog Workload Protection](https://daily.dev/posts/hardening-ebpf-for-runtime-security-lessons-from-datadog-workload-protection-luuhfraro) · eBPF · 6 upvotes · 0 comments - [BugBash'26 Morning of Day 1](https://daily.dev/posts/bugbash-26-morning-of-day-1-sf3epjk5i) · Metadata · 0 upvotes · 0 comments --- Tags: [#linux](https://daily.dev/tags/linux), [#gpu](https://daily.dev/tags/gpu), [#cuda](https://daily.dev/tags/cuda) [View this post on daily.dev](https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA Verification","url":"https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt"},"datePublished":"2026-08-11T08:54:34.288Z","dateModified":"2026-08-11T09:15:03.836Z","description":"A comprehensive taxonomy of 19 GPU bug classes for CUDA verification, organized by impact type (Safety, Correctness, Performance) and GPU specificity...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b59e04eefe0ea85df0b7e50151b0b12e?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b59e04eefe0ea85df0b7e50151b0b12e?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"eunomia eBPF Blog","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"eunomia eBPF Blog","logo":"https://media.daily.dev/image/upload/s--z-nTl7TK--/f_auto,q_auto/v1786438304/logos/eunomia?_a=BAMAMicg0","url":"https://daily.dev/sources/eunomia"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"linux,gpu,cuda","timeRequired":"PT50M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"eunomia eBPF Blog","item":"https://daily.dev/sources/eunomia"},{"@type":"ListItem","position":3,"name":"A Taxonomy of GPU Bugs: 19 Defect Classes for CUDA Verification"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/a-taxonomy-of-gpu-bugs-19-defect-classes-for-cuda-verification-jss2kpgpt#faq","mainEntity":[{"@type":"Question","name":"What are the main categories of bugs in CUDA GPU programming and how are they classified?","acceptedAnswer":{"@type":"Answer","text":"CUDA GPU bugs fall into 19 classes organized by impact type (Safety, Correctness, Performance) and GPU specificity (GPU-specific, GPU-amplified, CPU-shared). GPU-specific bugs include barrier divergence, invalid warp sync, insufficient atomic scope, warp-divergence races, uncoalesced memory access, and shared-memory data races. GPU-amplified bugs include atomic contention, non-barrier deadlocks, and kernel non-termination. CPU-shared bugs include global-memory data races, memory safety violations, and arithmetic errors. Teams building or auditing CUDA kernels track emerging verification research and tooling on daily.dev."}},{"@type":"Question","name":"How many CUDA GPU bug classes can be verified without inspecting the host kernel using Extension-local analysis?","acceptedAnswer":{"@type":"Answer","text":"14 of 19 GPU bug classes can be fully addressed through Extension-local verification, examining only the policy code without inspecting the host kernel. Three of these (#2 Invalid Warp Sync, #10 Missing Volatile/Fence, #15 Non-Barrier Deadlocks) can be eliminated by construction through language restrictions. Four others (#3, #5, #14, #17) initially appear to require Combined analysis but reduce to Extension-local through state isolation. Developers designing GPU extension frameworks find the latest verification research on daily.dev."}},{"@type":"Question","name":"What tools can detect barrier divergence bugs in CUDA kernels?","acceptedAnswer":{"@type":"Answer","text":"Barrier divergence in CUDA kernels can be detected by GPUVerify (static verification proving divergence freedom via uniformity reasoning), Compute Sanitizer synccheck (runtime detection reporting 'divergent thread(s) in block'), and Simulee (evolutionary simulation-based bug finding in real-world code). Wu et al.'s empirical study explicitly classifies barrier divergence under improper synchronization as a CUDA-specific root cause. CUDA developers staying ahead of GPU correctness tooling follow new releases and research on daily.dev."}}]} ```