Threadprocs – exécutables partageant un espace d'adressage unique (pointeurs sans copie)
Ce projet lance plusieurs programmes indépendants dans un seul espace d'adressage virtuel partagé, tout en se comportant comme des processus distincts (binaires, variables globales et durées de vie indépendants). Lorsque les threadprocs partagent leur espace d'adressage, les pointeurs restent valides entre eux sans modification de code pour les binaires Linux bien comportés. Contrairement aux threads, chaque threadproc est un processus autonome et semi-isolé. Contrairement aux systèmes de plugins basés sur dlopen, les threadprocs exécutent des exécutables traditionnels avec une fonction `main()`. Contrairement aux processus POSIX, les pointeurs restent valides entre les threadprocs car ils partagent le même espace d'adressage. Cela signifie que des structures de données idiomatiques basées sur des pointeurs comme `std::string` ou `std::unordered_map` peuvent être transmises entre les threadprocs et accédées directement (avec les considérations habituelles de course aux données). Cela réalise un modèle de programmation à mi-chemin entre les pthreads et l'IPC par mémoire partagée multi-processus. L'implémentation repose sur la direction de l'ASLR et de la disposition des adresses virtuelles au moment du chargement, ainsi que sur l'implémentation d'un analogue en espace utilisateur de `exec()`, et sur une manipulation minutieuse des descripteurs de fichiers, signaux, etc. des threadprocs. Elle est entièrement implémentée en code espace utilisateur non privilégié : < https://github.com/jer-irl/threadprocs/blob/main/docs/02-imp... >. Il existe une démonstration simple montrant le déréférencement mémoire « cross-threadproc » à < https://github.com/jer-irl/threadprocs/tree/main?tab=readme-... >, incluant un diagramme de haut niveau. Ceci est pertinent pour les systèmes à processus multiples avec mémoire partagée (souvent des tampons circulaires ou des tables plates). Ces conceptions nécessitent souvent de la sérialisation ou de la copie, et s'éloignent des structures de données idiomatiques en C++ ou Rust. Les structures de données basées sur des pointeurs ne peuvent pas être transmises directement. Il existe des limitations importantes et des cas particuliers, et il n'est pas certain que ce soit un modèle pratique, mais le projet explore une manière d'assouplir les frontières mémoire traditionnelles des processus tout en structurant un système comme des composants lancés indépendamment.
- Automatisation des Flux de Travail
- Cloud Native
- Génération de Code
✨ Résumé IA
Threadprocs permet à plusieurs exécutables indépendants de s'exécuter dans un seul espace d'adressage virtuel partagé, permettant un accès direct par pointeurs entre eux tout en maintenant une isolation de type processus. Cette approche offre un compromis entre les threads et la mémoire partagée multi-processus traditionnelle.
Idéal pour
Programmateurs système explorant de nouvelles méthodes de communication inter-processus, Développeurs travaillant avec de grandes structures de données interconnectées entre composants, Chercheurs étudiant les techniques d'isolation et de partage de mémoire
Pourquoi c'est important
Permet le partage direct et sans copie de structures de données basées sur des pointeurs entre exécutables lancés indépendamment en leur permettant de partager un seul espace d'adressage.
Fonctionnalités clés
- Lance des programmes indépendants dans un seul espace d'adressage virtuel partagé.
- Maintient un comportement distinct de type processus (binaires, variables globales, durées de vie).
- Permet le partage de pointeurs sans copie entre 'threadprocs' sous Linux.
- Prend en charge l'accès direct aux structures de données idiomatiques C++/Rust (par exemple, std::string).
Cas d'usage
- Un développeur de jeu pourrait utiliser threadprocs pour charger différents modules du jeu (par exemple, IA, physique, rendu) comme des exécutables indépendants qui partagent le même espace mémoire. Cela permettrait le passage direct, sans copie, de structures de données complexes comme des graphes de scène ou des états de personnage entre les modules, simplifiant la communication inter-module comparée à l'IPC traditionnel ou à la sérialisation.
- Un programmeur système construisant un pipeline de traitement de données haute performance pourrait employer threadprocs pour exécuter des étapes de traitement distinctes (par exemple, ingestion, transformation, analyse) comme des binaires séparés. Cette architecture permettrait la manipulation directe de tampons de données partagés, comme des grands tableaux ou des graphes d'objets complexes, sans les frais généraux de copie ou de sérialisation, améliorant potentiellement le débit.
- Un chercheur développant un environnement de simulation complexe pourrait tirer parti de threadprocs pour gérer différents composants de simulation (par exemple, comportement d'agents, interactions environnementales, journalisation de données) comme des programmes compilés indépendamment. Cela permettrait un partage fluide de l'état de simulation et un accès direct aux structures de données partagées, facilitant le prototypage rapide et l'itération sur la logique de simulation.