Encontré este código para compareAndSwap en una respuesta de StackOverflow :
boolean CompareAndSwapPointer(volatile * void * ptr, void * new_value, void * old_value) { #if defined(_MSC_VER) if (InterlockedCompareExchange(ptr, new_value, old_value) == old_value) return false; else return true; #elif (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100 return __sync_bool_compare_and_swap(ptr, old_value, new_value); #else # error No implementation #endif }¿Es esta la forma más adecuada de tener un código rápido portátil (excepto el ensamblado en línea)?
Además, un problema es que esos métodos builtin específicos tienen diferentes parámetros y devuelven valores de un compilador a otro, lo que puede requerir algunos cambios adicionales como el if then else en este ejemplo.
También otro problema sería el comportamiento de estos métodos builtin en el nivel de código de máquina, ¿se comportan exactamente igual? (por ejemplo, utilice las mismas instrucciones de montaje)
Nota: Otro problema sería si hay muchas plataformas compatibles no solo ( Windows y Linux ) como en este ejemplo. El código puede llegar a ser muy grande.
Usaría una capa de abstracción de hardware (HAL) que permite que el código genérico sea común, y cualquier fuente portátil se puede incluir y compilar para cada plataforma.
En mi opinión, esto permite una fuente mejor estructurada y más legible.
Para permitirle comprender mejor este proceso, sugeriría Google para encontrar ejemplos y explicaciones.
Esperemos que esta breve respuesta ayude.
[EDITAR] Intentaré un ejemplo simple para Bionix, para mostrar cómo implementar un sistema HAL...
mrAMainApplication.c contiene lo siguiente...
#include "hal.h" // This gets called every time around the main loop ... void mainProcessLoop( void ) { unsigned char key = 0; // scan key ... key = hal_ReadKey(); if ( key != 0 ) { hal_PrintChar( key ); } }Luego crea un archivo de encabezado (Recuerde: ¡este es un ejemplo, no es un código de trabajo!) ... Él crea hal.h ...
#ifndef _HAL_H_ #define _HAL_H_ unsigned char hal_ReadKey( void ); unsigned char hal_PrintChar( unsigned char pKey ); #endif // _HAL_H_Ahora el Sr. A necesita dos archivos fuente separados, uno para su sistema 'Tianhe-2' y otro para su Amiga 500...
hal_A500.c
void hal_ReadKey( void ) { // Amiga related code for reading KEYBOARD } void hal_PrintChar( unsigned char pKey ) { // Amiga related code for printing to a shell... }hal_Tianhe2_MUY RÁPIDO.c
void hal_ReadKey( void ) { // Tianhe-2 related code for reading KEYBOARD } void hal_PrintChar( unsigned char pKey ) { // Tianhe-2 related code for printing to a shell... }El Sr. A luego, cuando construye para Amiga, construye mrAmainApplication.c y hal_A500.c Cuando construye para Tianhe-2, usa hal_Tianhe2_VERYFAST.c en lugar de hal_A500.c
Correcto, he escrito este ejemplo con algo de humor, esto no está destinado a nadie, solo siento que hace que el ejemplo sea más interesante y, con suerte, ayuda a comprenderlo.
neil
Eche un vistazo a ConcurrencyKit y posiblemente pueda usar primitivas de nivel superior, que es probablemente lo que la gente realmente quiere la mayoría de las veces. A diferencia de HAL, que es algo específico del sistema operativo, creo que CK funciona en Windows y con varios compiladores que no son gcc.
Pero si solo está interesado en cómo implementar "comparar e intercambiar" o acciones atómicas de forma portátil en una amplia variedad de compiladores de C, mire y vea cómo funciona ese código. Todo es de código abierto.
Sospecho que los detalles pueden complicarse y que, en general, no serán una exposición fácil o interesante para el público en general.
En C moderno, comenzando con C11, use _Atomic para la calificación de tipo y atomic_compare_exchange_weak para la función.
Las versiones más nuevas de gcc y clang cumplen con C11 e implementan estas operaciones de manera portátil.