Comment effectuer des opérations atomiques sur Linux qui fonctionnent sur des systèmes x86, arm, GCC et de la cpi?

Projets sont à l'aide de ceci:

http://packages.debian.org/source/sid/libatomic-ops

Si vous voulez des opérations simples comme CAS, ne pouvez-vous pas tout simplement utiliser l'arc des implémentations spécifiques hors du noyau, et de faire de l'arche de contrôles dans l'espace utilisateur avec les autotools/cmake? Aussi loin que l'octroi de licences va, même si le noyau est en GPL, je pense qu'il est possible de soutenir que la assembly en ligne de ces opérations est fourni par Intel/AMD, pas que le noyau a une licence sur eux. Ils ont juste arriver à être dans une forme aisément accessible dans le source du noyau.

Darn. J'allais suggérer la GCC primitives, puis vous avez dit qu'ils étaient hors de portée. 🙂

Dans ce cas, je ferais une #ifdef pour chaque architecture/compilateur combinaison que vous aimez et le code de l'asm inline. Et peut-être vérifier pour __GNUC__ ou d'une même macro et d'utiliser GCC primitives s'ils sont disponibles, parce qu'il se sent tellement plus droit à l'utilisation de ceux-ci. 🙂

Vous allez avoir beaucoup de duplication et il peut être difficile de vérifier l'exactitude, mais cela semble être la façon dont beaucoup de projets à faire, et j'ai eu de bons résultats avec elle.

Certains pièges qui ont peu de moi dans le passé: lorsque vous utilisez GCC, n'oubliez pas les "asm volatile" et clobbers pour "memory" et "cc", etc.

Que j'ai fait récemment une mise en œuvre d'une telle chose et j'ai été confronté aux mêmes difficultés que vous. Ma solution a été de essentiellement les suivantes:

• essayer de détecter la gcc avec les builtins
  la fonction macro
• si ne sont pas disponibles juste en œuvre
  quelque chose comme cmpxch avec __asm__ pour les autres architectures (ARM est un peu plus compliqué que cela). Juste le faire pour une taille possible, l'e.g sizeof(int).
• mettre en œuvre toutes les autres fonctionnalités sur
  le dessus de cela un ou deux primitives
  avec inline fonctions

__sync* est certainement (et a été) pris en charge par le compilateur Intel, car GCC a adopté ces build-ins à partir de là. Lisez le premier paragraphe de sur cette page. Voir aussi "Intel® Compilateur C++ pour Linux* Intrinsèques de Référence", page 198. C'est à partir de 2006 et décrit exactement ceux built-ins.

Concernant le soutien de BRAS, pour les anciens Processeurs ARM: il ne peut pas être entièrement effectuée dans l'espace utilisateur, mais il peut être fait dans kernelspace (par la désactivation des interruptions au cours de l'opération), et je pense que j'ai lu quelque part qu'il est pris en charge pour un certain temps maintenant.

Selon ce bogue de PHP, daté 2011-10-08, __sync_* échoue seulement sur

• PA-RISC avec autre chose que Linux
• SPARCv7 et inférieur
• BRAS avec GCC < 4.3
• ARMv5 et inférieure avec autre chose que Linux
• MIPS1

Donc avec GCC > en 4.3 et 4.7 est l'actuel), vous ne devriez pas avoir un problème avec ARMv6 et les plus récents. Vous ne devriez avoir aucun problème avec ARMv5 soit en tant que de compiler pour Linux.

Voir: kernel_user_helpers.txt ou d'entrée de bras.c et de regarder pour __kuser_cmpxchg. Comme on le voit dans les commentaires de l'autre BRAS versions de Linux,

kuser_cmpxchg

Emplacement: 0xffff0fc0 

Référence prototype: 

int __kuser_cmpxchg(int32_t oldval, int32_t newval, la volatilité des int32_t *ptr); 

Entrée: 

r0 = oldval 
r1 = newval 
r2 = ptr 
lr = adresse de retour 

Sortie: 

r0 = code de réussite (nulle ou non nulle) 
C flag = ensemble si r0 == 0, clair, si r0 != 0 

Tabassé registres: 

r3, ip, drapeaux 

Définition: 

Atomiquement magasin newval dans *ptr seulement si: *ptr est égal à oldval. 
De retour à zéro si *ptr a été modifié ou non-zéro si aucun échange n'est arrivé. 
Le C indicateur est également défini si *ptr a été modifiée afin de permettre l'assemblée 
l'optimisation dans le code appelant. 

Exemple d'utilisation: 

 typedef int (__kuser_cmpxchg_t)(int oldval, int newval, volatile int *ptr);
 #define __kuser_cmpxchg (*(__kuser_cmpxchg_t *)0xffff0fc0)

 int atomic_add(volatile int *ptr, int val)
 {
        int old, new;

        do {
                old = *ptr;
                new = old + val;
        } while(__kuser_cmpxchg(old, new, ptr));

        return new;
}

Notes:

• Cette routine comprend déjà les barrières de la mémoire au besoin.
• Valable que si __kuser_helper_version >= 2 (à partir de la version du noyau 2.6.12).

C'est pour une utilisation avec Linux avec ARMv3 à l'aide de la swp primitive. Vous devez avoir une très ancien BRAS de ne pas soutenir cette. Seulement un données abandonner ou interrompre peut provoquer le fait de tourner à l'échec, de sorte que le noyau des moniteurs pour cette adresse ~0xffff0fc0 et effectue un de l'espace utilisateur PC fix-up lorsqu'un données abandonner ou un interrompre se produit. Tout utilisateur de l'espace des bibliothèques qui prennent en charge ARMv5 et inférieurs utiliser cette facilité.

Par exemple, QtConcurrent utilise cette.