The Chromium Chronicle n. 25: annotazioni sulla sicurezza dei thread

Episodio 25: di Victor Costan in SFO (ottobre 2021)
Puntate precedenti

In C++, l'esclusione della possibilità di gare di dati si riduce a una piccola prova di correttezza della sicurezza dei thread per ogni accesso dei membri dei dati. Queste prove comportano un grande impegno mentale, soprattutto durante la revisione o il refactoring del codice. Il framework di analisi statico di Clang prende il carico sulle prove di sicurezza dei thread.

Aggiungi GUARDED_BY_CONTEXT() ai membri dei dati nelle classi non sicure per i thread

La maggior parte delle classi di Chrome non è sicura per i thread e dovrebbe essere utilizzata in una singola sequenza. Aggiungi annotazioni a tutti i membri dei dati che non sono sicuri per i thread. Le annotazioni non necessarie sono sicure, ma la mancanza di annotazioni comporta il rischio di elusione dei dati.

#include "base/sequence_checker.h"  // for SEQUENCE_CHECKER()
#include "base/thread_annotations.h"  // for GUARDED_BY_CONTEXT()

class Cache {
  // Methods here.
 private:
  SEQUENCE_CHECKER(sequence_checker_);
  base::flat_map<std::string, std::string> data_ GUARDED_BY_CONTEXT(sequence_checker_);
};

Clang forza i controlli delle sequenze

In cambio dell'annotazione dei membri dei dati, Clang garantisce che qualsiasi metodo che accede ai dati esegua un controllo di sicurezza della sequenza prima di farlo. Man mano che il codice viene spostato durante il refactoring, Clang continua ad applicare l'annotazione GUARDED_BY_CONTEXT().

void Cache::Set(base::StringPiece key, base::StringPiece value) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);  // Clang warns without this.
  data_.emplace(key, value);
}

Aggiungi GUARDED_BY() ai membri dei dati in classi con sicurezza thread che utilizzano i mutex

Alcune classi in Chrome devono utilizzare i blocchi per la sicurezza dei thread. In questi casi, annota tutti i membri di dati non sicuri per i thread. Ogni annotazione punta a un mutex che deve essere mantenuto durante l'accesso al membro dei dati.

#include "base/thread_annotations.h"  // for GUARDED_BY()

class ThreadSafeCache {
  // Methods here.
  private:
    base::Lock lock_;
    base::flat_map<std::string, std::string> data_ GUARDED_BY(lock_);
};

Clang forza le acquisizioni di blocco

Riprova e lascia che il compilatore si assicuri che l'ambito di ogni base::AutoLock sia corretto, e che le chiamate Acquire() e Release() di blocco siano accoppiate correttamente.

void ThreadSafeCache::Set(base::StringPiece key, base::StringPiece value) {
  base::AutoLock auto_lock(lock_);  // Clang warns without this.
  data_.emplace(key, value);
}