Docker CP vulnerability Pod Isolation Challenges • Noisy neighbor −Impact performance on CPU, Memory, Bandwidth, Buffer IO, PIDs, File descriptors # kubectl run --rm -it bb --image=busybox sh / # abstracts the common virtualization components which implements a Rust-based VMM. • Written in Rust: Memory-safe language • Secure: Minimal hardware emulation • Flexible: Easy to customize to fit various network similar to C • Memory management without garbage collection • Designed for systems programming Rust is a multi-paradigm programming language focused on performance and safety, especially safe concurrency

virtual functions  constexpr functions can now:  use dynamic_cast() and typeid  do dynamic memory allocations, new / delete  contain try/catch blocks  But still cannot throw exceptions33 constexpr Pointers  Is shared_ptr thread safe?  Yes: control block manipulation thread safe  guarantees object is deleted exactly once  No: accessing pointer not thread-safe, one thread could be reading pointer pointer, while another thread could be storing new pointer  Make it thread-safe?  Manually use mutex to protect access to smart pointer  Use global non-member atomic operations, e.g. std::atomic_load()

Cross platform - Performance - Thread Safe - Memory Safe - Love 利用 Rust 重塑移动应用开发 Rust 在移动应用 开发中的应用 Why Rust? - Cross platform - Performance - Memory Safe - Love 利用 Rust 重塑移动应用开发 PhoTto / image mobile platforms is increasingly gaining attention from developers. With its impressive performance, memory safety, and concurrency features, Rust has become an ideal choice for building high-performance

Embark), even it has paid contributors! Tokio is good enough Tokio Tokio's APIs are memory-safe, thread-safe, and misuse-resistant. This helps prevent common bugs, such as unbounded queues, buffer Software Enqueue Software Producer Consumer Consumer Consumer • Synchronization latency • Memory/Cache latency • CPU cycles latency DLB ： Dynamic Load Balance DLB Enqueue Logic Head and Tail Load Balancer Producer Producer Consumer Consumer Consumer • No Synchronization latency • No memory/cache latency • No CPU cycles DLB-Assist Channel Intro Hardware Senders Receive Senders Senders

danielanderson.net std::atomic How many lines does it take to implement a lock-free & memory-safe stack? template struct Stack { struct Node { T t; shared_ptr next; }; danielanderson.net std::atomic How many lines does it take to implement a lock-free & memory-safe stack? Since GCC-12 Since MSVC v19.30 Not lock free Not lock free atomic Lock free (throughput) Machine setup: • 4x Xeon E7-8867 (72 cores, 144 hyperthreads) • 1TB DDR4 main memory • Running Ubuntu 20.04 • Compiling with GCC 1339 Daniel Anderson -- danielanderson.net Libstdc++

from SRC 1 5 4 Safe to use pointer A SRC A hazard pointer is a single-writer multi-reader pointer. set HP to A if SRC == A clear HP 2 3 6 if HP != A HP Safe to delete A A 7 8 SAFE ACCESS If a hazard Protector Remover / Reclaimer Hazard pointers protect access to objects that may be removed concurrently. SAFE RECLAMATION Concurrency TS2 Essential Hazard Pointer Interface Base class for protectable objects Working Draft, Extensions to C++ for Concurrency Version 2 (wg21.link/n4895).  Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects, IEEE Transactions on Parallel and Distributed Systems. 15 (8):

Project "RustBelt" 2015-2021 Unlike C/C++, Rust is a safe language But, like C/C++, Rust is also an unsafe language There are guaranteed memory safety, thread safety, ... There are plenty of unsafe

my::shared_ptr(block); } // FixMe: What about alignment? // ToDo: Are these reinterpret_casts safe? // CheckThis: What if T() throws? // Why am I manipulating bytes? // This was supposed to be

int i = co_await compute_helper_async(data); /* ... */ } Because of the nested scopes, it’s safe to pass locals by reference to callees... … no dynamic allocation or reference counting