Desligando JIT, e controlando codeflow em MSIL (próprio VM)

Question

Eu estou escrevendo minha própria linguagem de script em C #, com algumas características que eu gosto, e eu escolhi usar MSIL como bytecode de saída (Reflection.Emit é bastante útil, e eu não tenho que pensar em outra bytecode). Ele funciona, emite executável, que pode ser executado (mesmo compilado com refletor :)) e é bastante rápido.

Mas - Eu quero executar vários 'processos' em um processo de + um fio, e controlar seu tempo de CPU atribuído manualmente (também implementar muito mais robusto IPC que é oferecido pelo framework .NET) Existe alguma maneira de desabilitar inteiramente JIT e criar própria VM, pisando instrução de pós-instrução usando o framework .NET (e uso de memória de controle, etc.), sem necessidade de escrever qualquer coisa no meu próprio, ou para alcançar este I deve escrever toda MSIL interpretar?

EDIT 1): Eu sei que a interpretação IL não é a coisa mais rápida do universo:)

EDIT 2): Para esclarecer - Eu quero a minha VM para ser uma espécie de 'sistema operacional' - ele fica algum tempo de CPU e divide entre processos, alocação de memória controles para eles, e assim por diante. Ele não tem que ser rápido, nem eficaz, mas apenas uma prova de conceito para alguns dos meus experimentos. . Eu não necessidade de implementá-lo no nível de processar todas as instruções - se isso deve ser feito por .NET, eu não vou me importo, eu só quero dizer: uma etapa de instrução, e esperar até que eu lhe disse para a etapa seguinte

EDIT 3):. Percebi, que ICorDebug pode talvez fazer minhas necessidades, agora olhando para implementação de runtime Mono

Answer 1

Você pode usar Mono - Acredito que permite uma opção para interpretar a IL vez de JITting-lo . O fato de que é meio de código aberto (sujeito a licenciamento) que você deve ser capaz de modificá-lo de acordo com suas necessidades, também.

Mono não tem todas as funcionalidades do .NET, é certo -. Mas pode fazer tudo que você precisa

Answer 2

Tenha em atenção que MSIL foi projetado para ser analisado por um compilador JIT. Não é muito adequado para um intérprete. Um bom exemplo é talvez a instrução ADD. Ele é usado para adicionar uma grande variedade de valores de tipo de valor: byte, short, int32, int64, ushort, uint32, uint64. O compilador sabe que tipo de add é necessário, mas você vai perder essa informação tipo ao gerar o MSIL.

Agora você precisa encontrá-lo de volta em tempo de execução e que exige a verificação dos tipos dos valores na pilha de avaliação. Muito lento.

Um facilmente interpretado IL tem instruções ADD dedicados como ADD8, ADD16, etc.

Answer 3

implementação Microsofts do Common Language Runtime tem apenas um sistema de execução, o JIT. Mono, por outro lado, vem com ambos, um JIT e um intérprete.

No entanto, eu não compreender totalmente o que exatamente você quer fazer-se e o que você gostaria de deixar para a implementação Microsofts:

Existe alguma maneira de desabilitar inteiramente JIT e criar própria VM?

e

... sem necessidade de escrever qualquer coisa no meu próprio, ou para alcançar este I deve escrever toda MSIL interpretar?

é uma espécie de contradizer.

Se você pensa, você pode escrever um sistema de execução melhor do que Microsofts JIT, você terá que escrever a partir do zero. Tenha em mente, no entanto, que ambos os Microsofts e monos JIT são altamente otimizadas compiladores. (Programação tiroteio idioma)

Ser capaz de tempo de CPU programação para operar processos do sistema exatamente não é possível a partir do modo de usuário. Essa é a tarefa sistemas operacionais.

Alguns implementação de tópicos verdes pode ser uma ideia, mas que é definitivamente um tópico para código não gerenciado. Se é isso que você quer, ter um olhar para a API hospedagem CLR.

Gostaria de sugerir, você tenta implementar o seu idioma no CIL. Afinal, ele é compilado até x86 cru. Se você não se preocupam com a comprovação, você pode usar ponteiros quando necessário.

Answer 4

Uma coisa que você pode considerar fazer é gerar o código em um estilo state-máquina. Deixe-me explicar o que quero dizer com isto.

Quando você escrever métodos de geradores em C # com o retorno de rendimento, o método é compilado em uma classe IEnumerator interna que implementa uma máquina de estado. O código do método é compilado em blocos lógicos que são terminados com uma indicação da ruptura retorno rendimento ou o rendimento, e cada bloco corresponde a um estado numerados. Porque cada retorno rendimento deve fornecer um valor, cada bloco termina por armazenar um valor de um campo local. O objeto enumerador, a fim de gerar o seu valor seguinte, chama um método que consiste em um comunicado gigante ligar o número de estado atual, a fim de executar o bloco atual, em seguida, avança o estado e retorna o valor do campo local.

A sua linguagem de script pode gerar seus métodos em um estilo semelhante, onde um método corresponde a um objeto de máquina de estado, e tempo da VM aloca avançando a máquina de estado durante o tempo previsto. Algumas partes difíceis para este método:. Execução coisas como chamadas de método e tentar / finally blocos são mais difíceis de gerar straight-up MSIL