Thread Local Storage - Définition

Introduction

Le Thread Local Storage (TLS), ou mémoire locale de thread, est un type de mémoire spécifique et locale à un thread.

Ce mécanisme est parfois requis parce que tous les threads d'un même processus partagent le même espace d'adressage. Donc, les données situées dans une variable statique ou globale sont exactement au même emplacement mémoire pour tous les threads, et correspondent donc à la même entité.

Les variables sur la pile sont toutefois locales au thread, parce que chaque thread possède sa propre pile, distincte de celle des autres threads.

Cependant, il est parfois utile que deux threads puissent référencer la même variable « globale » tout en possédant chacun une copie distincte, donc à des adresses mémoire différentes. Ceci rend la variable « locale » au thread, tout en ayant une syntaxe d'utilisation identique à celle d'une variable globale. Un exemple trivial d'une telle variable est, par exemple, la variable errno du langage C.

S'il est possible de rendre au minimum un pointeur local aux threads, alors il est possible de créer pour chaque thread du système une zone mémoire de taille arbitraire contenant des données locales de thread. En effet, cette zone peut elle-même être un simple tableau de pointeurs, ce qui permet ensuite (par déréférencements successifs) d'obtenir un TLS de taille totalement arbitraire, quelle que soit la limite initiale de la zone.

Illustration

Principle générique du TLS

Le processus possède ici deux threads. On alloue deux slots du TLS : le premier pour stocker un entier (index 2), le second pour stocker un pointeur (index 4), en bleu clair. Chaque thread va alors obtenir une zone mémoire privée (parties vert sombre pour le thread 1, bleu sombre pour le thread 2), permettant d'accéder à sa donnée locale, éventuellement via une indirection pour le pointeur, tout en n'utilisant qu'un index global et identique entre les deux (simplification du code).

Implémentations spécifiques

En plus de la possibilité d'appeler les fonctions natives du système d'exploitation décrites ci-dessus, certains langages ou compilateurs permettent d'utiliser une fonctionnalité équivalente, voire identique, au TLS de façon plus simple et/ou plus pratique que faire appel aux primitives système.

Compilateurs et IDE

Visual C++ et Intel C++ Compiler (Windows)

Le mot-clé __declspec(thread) est utilisé en préfixe de déclaration :

          int variable_globale;          __declspec(thread) int variable_TLS ;      

La variable TLS est ensuite utilisable de façon tout à fait normale.

Sun Studio, IBM XL C/C++ et Intel C++ Compiler (Linux)

Le mot-clé __thread est utilisé en préfixe de déclaration :

          int variable_globale ;          __thread int variable_TLS ;      

La variable TLS est ensuite utilisable de façon tout à fait normale.

Digital Mars C++

Le mot-clé __declspec(thread) est utilisé en préfixe de déclaration :

          int variable_globale ;          __declspec(thread) int variable_TLS ;      

La variable TLS est ensuite utilisable de façon tout à fait normale.

Borland C++ Builder (Windows)

Le mot-clé __declspec(thread) est utilisé en préfixe de déclaration :

          int variable_globale  ;          __declspec(thread) int variable_TLS ;      

Le mot-clé __thread est une alternative de déclaration, mais entre le type et l'identifiant :

          int variable_globale  ;          int __thread variable_TLS ;      

Dans les deux cas, la variable TLS est ensuite utilisable de façon tout à fait normale.

GCC/G++

Le mot-clé __thread est utilisé en préfixe de déclaration, mais est implémenté de façon particulière :

          int variable_globale  ;          __thread int variable_TLS = 1 ;      

Toutefois, la variable TLS doit impérativement être initialisée avec une constante connue au moment de la compilation (cas de l'exemple ci-dessus).

Il n'est pas autorisé de déclarer une variable TLS sans initialisation, ou étant initialisée par un paramètre et/ou un appel de fonction.

Langages

Delphi et Free Pascal

Le mot-clé ThreadVar est utilisé en lieu et place du traditionnel Var pour déclarer une variable TLS.

          Var              variable_globale : Integer ;          ThreadVar              variable_TLS : Integer ;      

La variable TLS est ensuite utilisable de façon tout à fait normale.

Java

En Java, les variables TLS sont implémentées au travers de la classe ThreadLocal (en). Un objet ThreadLocal maintient une instance séparée de la variable pour chaque thread appelant les accesseurs de l'objet (get et set).

L'exemple ci-dessous montre comment créer une variable entière TLS :

          ThreadLocal<Integer> variable_TLS = new ThreadLocal<Integer>() {              @Override protected Integer initialValue() {                  return 1;              }          } ;      

L'utilisation de la variable se fait au travers des accesseurs. Par exemple, une incrémentation :

          variable_TLS.set( variable_TLS.get() + 1 ) ;      

D

En D (version 2), toutes les variables statiques et globales sont, par défaut, locales aux threads et sont déclarées comme les variables « normales » des autres langages. C'est la déclaration explicite d'une variable globale « partagée » qui requiert l'utilisation d'un mot-clé spécifique, __gshared.

          int variable_TLS ;          __gshared int variable_globale  ;      

La variable TLS est ensuite utilisable de façon tout à fait normale, ainsi que la variable globale déclarée explicitement.

C# et langages .NET

On utilise l'attribut ThreadStatic (en) :

          class classe_avec_TLS {              [ThreadStatic] static int variable_TLS ;          }      

Également, on peut allouer dynamiquement des variables TLS via l'API Thread.GetNamedDataSlot (en).

La variable TLS est ensuite utilisable de façon tout à fait normale.

Python

En Python (version 2.4 ou supérieure), on utilise la classe local du module threading pour définir une variable TLS.

          import threading          variable_TLS = threading.local()          variable_TLS.x = 1      

La variable TLS est ensuite utilisable de façon tout à fait normale.

Ruby

En Ruby, une variable TLS est créée et utilisée grâce aux méthodes []=/[].

          Thread.current[:index_TLS] = 1      

Perl

Le support des threads n'est arrivé que tardivement dans le langage Perl, après qu'une vaste quantité de code source fut présente sur Comprehensive Perl archive network. En conséquence de ceci, les threads en Perl créent par défaut leur propre TLS pour toutes les variables, de façon à minimiser l'impact des threads sur le code existant non thread-safe. En Perl, une variable partagée entre les threads (cas « normal » dans les autres langages) est créée en utilisant un attribut :

          use threads;          use threads::shared;                 my $variable_TLS;          my $variable_globale  :shared;