Teilen Lock-weniger Ressourcen zwischen Threads in Rust

Question

ich die Portierung meiner C++ Schach-Engine in Rust. Ich habe eine große Hash-Tabelle zwischen Such-Threads geteilt und in der C++ - Version ist diese Tabelle gesperrt; Es gibt keinen Mutex für das Teilen des Lese-/Schreibzugriffs. Hier ist the theory, wenn Sie interessiert sind.

Im Rust Version dieses Codes ist es gut funktioniert, nutzt aber ein Mutex:

let shared_hash = Arc::new(Mutex::new(new_hash())); 

for _ in 0..n_cpu { 
    println!("start thread"); 
    let my_hash = shared_hash.clone(); 
    thread_pool.push(thread::spawn(move || { 
     let mut my_hash = my_hash.lock().unwrap(); 
     let mut search_engine = SearchEngine::new(); 
     search_engine.search(&mut myhash); 
    })); 
} 

for i in thread_pool { 
    let _ = i.join(); 
} 

Wie kann ich den Tisch zwischen Threads ohne Mutex teilen?

Answer 1

Ganz einfach, eigentlich: die Mutex ist unnötig, wenn die zugrunde liegende Struktur bereits Sync ist.

In Ihrem Fall wäre ein Array von Strukturen von atomics zum Beispiel arbeiten. Sie können Rusts verfügbare Atomics here finden.

Answer 2

Wie bereits angedeutet, habe ich eine FakeMutex schrieb die Sync implementiert, aber nicht gesperrt wirklich die Hash-Tabelle:

use core::cell::UnsafeCell; 
use core::marker::Sync; 
use core::ops::{Deref, DerefMut}; 

pub struct FakeMutex<T> { 
    data: UnsafeCell<T>, 
} 

pub struct FakeMutexGuard<'a, T: 'a> { 
    data: &'a mut T, 
} 

unsafe impl<T> Sync for FakeMutex<T> {} 

impl<T> FakeMutex<T> { 
    pub fn new(user_data: T) -> FakeMutex<T> { 
     FakeMutex { 
      data: UnsafeCell::new(user_data), 
     } 
    } 

    pub fn lock(&self) -> FakeMutexGuard<T> { 
     FakeMutexGuard { 
      data: unsafe { &mut *self.data.get() }, 
     } 
    } 
} 

impl<'a, T> Deref for FakeMutexGuard<'a, T>{ 
    type Target = T; 
    fn deref<'b>(&'b self) -> &'b T { &*self.data } 
} 

impl<'a, T> DerefMut for FakeMutexGuard<'a, T>{ 
    fn deref_mut<'b>(&'b mut self) -> &'b mut T { &mut *self.data } 
} 

Mein neuer Code ist:

let shared_hash = Arc::new(FakeMutex::new(new_hash())); 

for _ in 0..n_cpu { 
    println!("start thread"); 
    let my_hash = shared_hash.clone(); 
    thread_pool.push(thread::spawn(move || { 
     let mut my_hash = my_hash.lock(); 
     let mut search_engine = SearchEngine::new(); 
     search_engine.search(&mut myhash); 
    })); 
} 

for i in thread_pool { 
    let _ = i.join(); 
} 

Diese meine Frage löst.

Answer 3

Data races are undefined behavior sowohl in C++ und Rost. Sprich: Nein, nur

Der richtige Weg ist Ihre Tabelle atomic integers aus zu bauen. Es ist Raketenwissenschaft. You have to decide case by case wie viel Sie care about the order of memory operations. Das macht Ihren Code überflutet:

// non-atomic array access 
table[h] = 0; 

// atomic array access 
table[h].store(0, Ordering::SeqCst); 

Aber es ist es wert.

nicht sagen, Es ist, was die Leistungseinbuße sein - man muss es einfach ausprobieren.