Plus difficile à construire: Emulator ou compilateur?

Question

Étant donné un développeur compétent avec 10-20 ans d'expérience qui n'a jamais construit soit un compilateur ou un émulateur, qui serait plus de défi?

Pourriez-vous comparer les questions qui seraient des barrages routiers pour les deux.

Merci.

Answer 1

Emulation et la compilation sont très différents, mais ont tendance à être localisés ensemble en raison de deux étant considérés comme « bas niveau ».

Emulation d'une architecture simple comme un 6502 ou Z80 sera assez simple pour le morceau CPU du travail, mais il y aura juste un morceau de code à écrire puisque vous devez avoir une fonction pour chaque instruction. Vous souhaitez automatiser ce en quelque sorte, à partir d'une spécification de jeu d'instructions avec tous les horaires et ce, en tapant tout cela en sera très pénible en effet :) Old specs ensemble d'instructions du processeur sont facile à trouver, ce qui aide beaucoup lors de la construction émulateurs.

En plus de cela, vous aurez besoin de mettre en œuvre un certain niveau de émulation de matériel , ce qui implique généralement la manipulation et les interruptions de production (telles que l'interruption vertical vide d'un dispositif d'affichage si l'émulateur est pour une console de jeu, par exemple). Ce nouveau aura besoin un certain niveau de spécification et la génération de code, mais vous aurez probablement écrire plus de cette main car il ne va pas être tout à fait si répétitif (et donc automatisable) que le code de jeu d'instructions.

La compilation comprendra une sorte de spécifications de langue de la langue que vous allez mettre en œuvre le compilateur pour, et une cible que vous viserons au code de sortie pour. La sortie pourrait être directement en binaire, pourrait être assemblée ou pourrait même être une autre langue (ce qui est vraiment juste un traducteur, mais il compte comme compilation lorsque la cible est considérée comme « suffisamment » de bas niveau). Puisque vous courrez sur une sorte de plate-forme matérielle ou VM alors vous serez probablement pas à vous soucier de la gestion des interruptions et ce genre de chose.

Stumbling blocs pour les deux sont complexité et correct - pour l'émulateur, vous devrez le faire fonctionner de manière très précise à moins que vous choisissez des choses très simples à imiter. Vous aurez également besoin de créer une sorte de débogueur intégré pour l'émulateur, sinon il est presque impossible de dire ce qui ne va pas quand il fait invariablement. Pour un compilateur, il devrait être assez straightforwward de traduire un langage de jouet ou un petit sous-ensemble d'un langage plus complexe, et le construire comme vous allez le long.

Rappelez-vous qu'avec ces deux éléments que vous devez être en mesure de produire entrée pour les tester, et si vous ne pouvez pas produire des entrées simples, vous trouverez qu'il est très difficile d'obtenir debug dès le début. Ce seul rend le travail du compilateur plus facile d'entrer dans, IMHO (Ce et que vous voulez avoir quelque chose qui émule une console complète ou quelque chose tout de suite:)

Answer 2

Je l'ai écrit à la fois et je dirais que les autres choses étant égales par ailleurs (complexité du langage ou d'instructions), il est chemin plus facile d'écrire un émulateur, surtout si vous essayez d'écrire un intéressant émulateur ou compilateur.

La raison est que, avec un émulateur que vous essayez de simuler une chose de bas niveau avec une autre, chose à faible niveau similaire. Ce n'est pas si mal. Avec un compilateur, vous pouvez essayer de mettre en œuvre des idées très haut niveau (par exemple, les objets, les fonctions de première classe, mémoire gérée, la numérisation de la chaîne) avec des outils très bas niveau (mots machine et les instructions de la machine). Cette tâche est juste beaucoup plus difficile.

Bien sûr, pour les gangs de plaisir, vous pouvez écrire un émulateur qui fonctionne par traduction binaire dynamique , qui est la compilation du code machine pour l'architecture émulé dans le code de la machine pour l'architecture native. De cette façon, vous obtenez d'avoir tout le plaisir des deux --- et yo produire émulateurs vraiment rapide comme QEMU ou la regrettée numérique FX! 32.

Answer 3

Je l'ai écrit à la fois et je dirais qu'un émulateur est généralement plus facile. Bien sûr, cela dépend en grande partie de ce que vous essayez d'imiter (émule un ordinateur central IBM sur un iPhone pourrait être un peu un défi) et ce que vous essayez de compiler (un compilateur petit C est assez facile, un compilateur complet C ++ presque incroyablement difficile.

Answer 4

Cela dépend en grande partie de ce que vous émulez, et ce que vous compilez.

• Un émulateur qui émule un système très simple (par exemple une calculatrice à 4 fonctions) sur un système très capable (par exemple un PC moderne) sera facile à écrire.
• Un compilateur qui compile un langage très simple pour une cible unique (par exemple quelque chose qui associe presque directement à l'ensemble de sortie) sera facile à écrire.
• un émulateur qui émule un système très complexe (par exemple un grand système informatique propriétaire) sur un système très simple (par exemple un PDA) sera très difficile d'écrire
• Un compilateur qui compile un langage de très haut niveau (par exemple C ++ complet) pour de nombreuses cibles sera très difficile d'écrire

Answer 5

À mon avis un compilateur complexe est plus difficile à écrire qu'un émulateur complexe pour la simple raison que le compilateur implique la théorie beaucoup plus.

Lors de la conception de votre langue XX il y a beaucoup de facteurs à considérer pour ne pas mentionner l'optimisation de la sortie du compilateur de code généré qui est un art noir en lui-même. Avec un émulateur, vous disposez d'un environnement déjà bien défini avec une langue pour la plupart bien défini que vous souhaitez mettre en œuvre.

En tout cas, je recommande tout le monde d'écrire et d'écrire un compilateur car il vous donne une meilleure compréhension de la programmation, tout comme le médecin a besoin de savoir sur l'anatomie du corps, même si il ne peut pas avoir besoin dans son travail quotidien.

EDIT: Je pense que les deux compétences sont très utiles et on peut effectivement les combiner - ils ne sont pas XOR.

Je voudrais ajouter à mon avis ci-dessus est que la création d'un langage de programmation non trivial y compris runtime bibliothèques d'interagir avec les pilotes, les bases de données, etc, et qui peuvent évoluer avec les futures versions, mais toujours rester en arrière compatible est l'un des plus difficiles domaines dans CS.

Je suis d'accord aussi que si la plate-forme est inconnue dire que vous êtes quelque chose ingénierie inverse alors il est beaucoup plus difficile de faire un émulateur, mais OTOH ce n'est pas ce que la question de l'OP allait, était-il?

Answer 6

L'émulation du logiciel est assez simple et donc relativement facile, mais il peut être fastidieux.

L'écriture d'un compilateur peut être très difficile, mais il est rendu plus simple soit ayant une bonne connaissance de travail ou en ayant un bon ensemble de spécifications (par exemple notation Backus-Naur) de la langue que vous écrivez le compilateur pour.

L'émulation du matériel peut être extrêmement difficile si votre objectif est de faire fonctionner l'émulateur sur de nombreuses plates-formes différentes (par exemple l'exécution de l'émulation d'un timing de lecteur de disquette-disque pourrait fonctionner sous MSDOS en utilisant les constantes de fudge correctes, mais l'émulation échoue sur une plate-forme multi-tâches comme Vista ou Linux). émulation de matériel est également extrêmement difficile lorsque les connaissances disponibles sont insuffisantes sur la façon dont le mode de fonctionnement est contrôlé par un logiciel. Cela force l'ingénierie inverse à long et ennuyeux avant que des progrès peuvent être réalisés.

Dans l'ensemble, je juge l'émulation d'être plus difficile.

Answer 7

Ecrire un émulateur une plate-forme connue émulé est pas difficile (vous pouvez aussi utiliser un émulateur de CPU pré-faites et gagner du temps de développement).

Ecrire un émulateur pour le matériel émulé inconnu est beaucoup plus difficile , et déplace la difficulté à des domaines différents à partir du code-développement: les mathématiques, la cryptanalyse, les protocoles de sécurité, etc. Et, en tant que développeur, tu dois ont patience pour le procès et d'erreurs impliqués dans le processus.

À titre d'exemple, il suffit de penser combien de temps CPS2 émulation requis (ROM CPS2 étaient crypté).

Answer 8

Hors contexte, il peut y avoir aucune réponse précise. Tout dépend de ce que vous voulez atteindre, et ce que vous êtes en compétition contre

Si c'est juste une « preuve de concept », puis dans les deux cas, il est assez simple.

Mais si vous essayez d'imiter un matériel complexe ou avec une grande précision, ou si vous souhaitez obtenir une qualité de compilation AAA, les choses peuvent rapidement devenir la complexité laid. La complexité apparaît non seulement dans les algorithmes / théorie du code « principal », mais aussi dans tous les outils de soutien que vous aurez à construire (débogueurs, désassembleurs, profileurs, etc.) afin que vous puissiez passer à l'étape suivante.

Cela dit, un autre aspect à considérer est que l'écriture d'un compilateur de travail pour à peu près tout langage de programmation là-bas est d'une complexité raisonnable. D'autre part, s'il y a du matériel là-bas qui est trivial à imiter, il y a aussi du matériel pour lequel l'écriture même un émulateur de base peut être très complexe.

Alors la peinture avec un pinceau large, je dirais en train d'écrire un compilateur est plus facile, parce que vous êtes à peu près assuré de réussir à obtenir une version de travail, quel que soit le matériel cible ou la langue. Il n'y a pas de garantie pour un émulateur.

Answer 9

L'écriture d'un compilateur est beaucoup plus difficile, puisque vous avez affaire à des choses de niveau beaucoup plus faible (liaison, ensemble qui est spécifique à votre architecture, etc.).

Un émulateur juste doit effectuer la logique de chaque instruction envoyé à (et je sais que je simplifie, mais je suppose que vous avez les spécifications pour le jeu d'instructions), maintenant, écrire un émulateur FAST est beaucoup plus difficile.