Update 2024fa.md

content/lsd-seminar/2024fa.md

@@ -21,7 +21,7 @@ Talks will be advertised on the [ucsc-lsd-seminar-announce](https://groups.googl
 |-------                |---------                                                              |---------                                                          |
 | [Oct 4](#oct-4)       | Jinsheng Ba                                                           | Testing Database Engines via Query Plans |
 | [Oct 11](#oct-11)     | Jonathan Castello                                                     | Inductive diagrams for causal reasoning |
-| [Oct 18](#oct-18)     | Bastian Köpcke                                                        | _TBD_ |
+| [Oct 18](#oct-18)     | Bastian Köpcke                                                        | Descend: A Safe Imperative GPU Programming Language |
 | [Oct 25](#oct-25)     | Haofan Zheng                                                          | _TBD_ |
 | [Nov 1](#nov-1)       | Justin Lubin                                                          | _TBD_ |
 | [Nov 8](#nov-8)       | Bhakti Shah                                                           | _TBD_ |
@@ -55,11 +55,17 @@ Talks will be advertised on the [ucsc-lsd-seminar-announce](https://groups.googl
 
 **Speaker:** Bastian Köpcke
 
-**Title:** _TBD_
+**Title:** Descend: A Safe Imperative GPU Programming Language
 
-**Abstract:** _TBD_
+**Abstract:** Programming massively parallel hardware such as Graphics Processing Units (GPU) is challenging to get right. Programmers must correctly and efficiently coordinate thousands of threads and their accesses to various shared memory spaces. Existing mainstream GPU programming languages, such as CUDA and OpenCL, are based on C/C++ inheriting their fundamentally unsafe ways to access memory via raw pointers. This facilitates easy to make, but hard to detect bugs, such as data races and deadlocks.
 
-**Bio:** _TBD_
+In this talk, I will present Descend, our approach to a safe GPU programming language. In contrast to prior safe high-level GPU programming approaches, Descend is an imperative low-level GPU programming language in the spirit of Rust, enforcing safe CPU and GPU memory management in the type system by tracking Ownership and Lifetimes. Descend introduces a new holistic GPU programming model where computations are hierarchically scheduled over the GPU's execution resources: grid, blocks, warps, and threads. Descend's extended Borrow checking ensures that execution resources safely access memory regions without data races. For this, we introduced views describing safe parallel access patterns of memory regions, as well as atomic variables. For memory accesses that cannot be checked by our type system, users can annotate limited code sections as unsafe.
+
+I will discuss the memory safety guarantees offered by Descend at the hands of examples, take a brief look at the formal type system, and show an evaluation of the current implementation using multiple benchmarks, demonstrating that the approach that we take with Descend is capable of expressing real-world GPU programs showing competitive performance compared to manually written CUDA programs that are lacking Descend's safety guarantees.
+
+This talk will be based on work that appeared at PLDI 2024: https://dl.acm.org/doi/10.1145/3656411
+
+**Bio:** Bastian is a Computer Science PhD student in the Parallel and Distributed Systems research group at the University of Münster, working closely with Michel Steuwer's programming language and compiler group at TU Berlin. He is interested in programming languages, verification and compiler techniques to enable safer and more productive programming of parallel hardware.
 
 ## Oct 25