Désactiver JIT et contrôler le flux de code dans MSIL (propre machine virtuelle)

Question

J'écris mon propre langage de script en C #, avec quelques fonctionnalités qui me plaisent, et j'ai choisi d'utiliser MSIL en tant que bytecode de sortie (Reflection.Emit est très utile et je n'ai pas à imaginer un autre bytecode). Cela fonctionne, émet un exécutable, qui peut être exécuté (même décompilé avec Reflector :)) et est assez rapide.

Mais - je veux exécuter plusieurs 'processus' dans un processus + un thread et contrôler manuellement le temps de traitement qui leur est attribué (implémenter également un IPC beaucoup plus robuste proposé par .NET Framework). Existe-t-il un moyen de désactiver complètement JIT? et créer sa propre machine virtuelle en suivant pas à pas les instructions à l’aide de .NET Framework (et contrôler l’utilisation de la mémoire, etc.), sans avoir à écrire quoi que ce soit, ni pour y parvenir, je dois écrire l’interprétation complète de MSIL?

EDIT 1): Je sais que l’interprétation de l’IL n’est pas la chose la plus rapide de l’univers:)

EDIT 2): Pour clarifier - je veux que ma VM soit une sorte de "système d’exploitation" - elle prend un peu de temps CPU et le divise entre les processus, contrôle l’allocation de mémoire pour eux, etc. Il ne doit pas être rapide ni efficace, mais simplement une preuve de concept pour certaines de mes expériences. Je n'ai pas besoin de l'implémenter au niveau du traitement de chaque instruction - si cela devait être fait par .NET, cela ne me dérangerait pas, je veux juste dire: instruction de la première étape et attendre que je vous ai dit de passer à l'étape suivante.

EDIT 3): Je me suis rendu compte que ICorDebug pouvait peut-être répondre à mes besoins, en regardant maintenant la mise en œuvre du runtime de Mono.

Answer 1

Vous pouvez utiliser Mono . Je crois que cela permet à une option d'interpréter l'IL au lieu de la JIT. . Le fait qu’il soit open source signifie (sous réserve de licence) que vous devriez pouvoir le modifier en fonction de vos besoins.

Certes, Mono ne possède pas toutes les fonctionnalités de .NET, mais il peut faire tout ce dont vous avez besoin.

Answer 2

Attention, MSIL a été conçu pour être analysé par un compilateur JIT. Ce n'est pas très approprié pour un interprète. Un bon exemple est peut-être l'instruction ADD. Il est utilisé pour ajouter une grande variété de valeurs de type valeur: octet, short, int32, int64, ushort, uint32, uint64. Votre compilateur sait quel type d’ajout est requis, mais vous perdrez ces informations de type lors de la génération du fichier MSIL.

Vous devez maintenant le retrouver au moment de l'exécution, ce qui nécessite de vérifier les types de valeurs de la pile d'évaluation. Très lent.

Un IL facile à interpréter possède des instructions ADD dédiées telles que ADD8, ADD16, etc.

Answer 3

La mise en oeuvre de Microsofts du Common Language Runtime n’a qu’un seul système d’exécution, le JIT. Mono, quant à lui, est accompagné d’un JIT et d’un interprète.

Toutefois, je ne comprends pas tout à fait ce que vous voulez faire vous-même et ce que vous aimeriez laisser à la mise en œuvre de Microsofts:

  

Existe-t-il un moyen de désactiver entièrement JIT et de créer sa propre machine virtuelle?

et

  

... sans avoir besoin d'écrire quoi que ce soit par moi-même, ou pour y parvenir, je dois écrire une interprétation complète de MSIL?

est en quelque sorte en contradiction.

Si vous pensez que vous pouvez écrire un meilleur système d’exécution que microsofts JIT, vous devrez l’écrire à partir de zéro. Gardez toutefois à l'esprit que les microsofts et les monos JIT sont des compilateurs hautement optimisés. (fusillade en langage de programmation)

Il n'est pas possible de programmer le temps processeur pour les processus du système d'exploitation à partir du mode utilisateur. C'est la tâche des systèmes d'exploitation.

Certaines implémentations de threads verts pourraient être une idée, mais il s’agit bien d’un sujet pour le code non managé. Si c'est ce que vous voulez, consultez l'API d'hébergement CLR.

Je suggérerais que vous essayez d'implémenter votre langage dans CIL. Après tout, il est compilé au format x86 brut. Si vous ne vous souciez pas de la vérifiabilité, vous pouvez utiliser des pointeurs si nécessaire.

Answer 4

Vous pouvez envisager de générer du code dans un style de machine à états. Laissez-moi vous expliquer ce que je veux dire par là.

Lorsque vous écrivez des méthodes de génération en C # avec return, cette méthode est compilée dans une classe IEnumerator interne qui implémente une machine à états. Le code de la méthode est compilé en blocs logiques qui se terminent par une déclaration de rendement ou de rupture de rendement, et chaque bloc correspond à un état numéroté. Parce que chaque retour de rendement doit fournir une valeur, chaque bloc se termine en stockant une valeur dans un champ local. Afin de générer sa valeur suivante, l’objet énumérateur appelle une méthode consistant en une instruction de commutateur géant sur le numéro de l’état en cours afin d’exécuter le bloc en cours, puis en avançant l’état et renvoyant la valeur du champ local.

Votre langage de script peut générer ses méthodes dans un style similaire, une méthode correspondant à un objet de machine à états et la machine virtuelle allouant du temps en faisant avancer la machine à états pendant le temps imparti. Quelques aspects délicats de cette méthode: implémenter des choses telles que les appels de méthode et les blocs try / finally est plus difficile que de générer un MSIL direct.