Palabra clave / macro explícita de seguridad de hilos para comprobación en tiempo de compilación.
Actualmente estoy trabajando en una aplicación en C++ de tamaño mediano a grande que tiene una interfaz en red (similar a un servicio RPC multinucleado).
La interfaz en red se comunica con un estado de aplicación bastante complejo. Creo que he hecho un buen trabajo manteniendo el estado no seguro para subprocesos (mapas, vectores, etc.) rodeado de mutex, pero no estoy seguro.
Creo que sería genial si pudiera especificar qué funciones son seguras para subprocesos y que se verifique en tiempo de compilación para no tener que ejecutar analizadores estáticos en mi código. Estoy de acuerdo en anotar todas mis funciones.
Actualmente estoy atascado tratando de encontrar una forma de cumplir los siguientes ejemplos con macros/metaprogramación de plantillas, pero si esto es posible nativamente, o si ya existe una biblioteca para hacer esto, preferiría usarla.
“`c++
void no_seguro_para_hilos foo() {
// código inseguro
}
void llamado_desde_multiples_hilos bar() {
foo(); // provoca un error en tiempo de compilación
}
<pre><code><br />“`c++
// nota la palabra clave/macro seguro_para_hilos, en comparación con no_seguro_para_hilos anterior
void seguro_para_hilos foo() {
std::lock_guard<std::mutex> lock(some_mutex);
// código inseguro
}
void llamado_desde_multiples_hilos bar() {
foo(); // no hay error
}
“`c++
void no_seguro_para_hilos foo() {
// código inseguro
}
void blah() {
foo(); // puntos extras si también detecta esto (debería ser un error)
}
void llamado_desde_multiples_hilos bar() {
blah();
}
“`
davy.ai
Como experto en TI especializado en C++, multihilo y g++, la pregunta en cuestión se refiere al desarrollo de una aplicación C++ de mediana a gran escala con una interfaz en red. La interfaz en red se comunica con un estado de aplicación complejo y la preocupación se centra en garantizar que la aplicación sea a prueba de hilos, especialmente en lo que respecta a operaciones de estado no seguras para hilos. Aunque el interrogante ha rodeado mapas, vectores, etc. con mutex, no está seguro de si esto es suficiente para garantizar operaciones seguras para hilos.
El interrogante visualiza un enfoque más proactivo para garantizar la seguridad de hilos de la aplicación mediante la verificación en tiempo de compilación. Quieren especificar funciones seguras para hilos y que estas sean verificadas en tiempo de compilación para evitar ejecutar analizadores estáticos en el código. Además, están dispuestos a anotar todas las funciones para lograr esto. Para ellos, sería genial contar con macros o metaprogramación de plantillas para cumplir con los siguientes ejemplos. Si no es posible de forma nativa, les gustaría saber si existe una biblioteca que pueda ayudar.
El primer ejemplo demuestra cuando se llama a una función insegura desde una función segura para hilos y el resultado es un error en tiempo de compilación. El segundo ejemplo muestra que una función segura llamada desde una función segura para hilos no debería generar ningún error. Finalmente, el ejemplo adicional muestra que cuando se llama a una función insegura desde una función insegura, que a su vez es llamada desde una función segura para hilos, se produce un error en tiempo de compilación.
Si bien el interrogante aún no ha encontrado una solución, estarán dispuestos a utilizar bibliotecas o macros existentes para simplificar el proceso.