Sistemas operacionais gerenciados como Microsoft Singularity e JNode são um conceito bastante interessante. Essencialmente, o sistema operacional é inicializado com código escrito em uma linguagem de baixo nível (C / C ++ / Assembly), que implementa essencialmente uma máquina virtual. O restante do sistema operacional (e todos os aplicativos da terra do usuário) é executado na máquina virtual. Há algumas grandes coisas sobre isso. Por exemplo, você repentinamente torna obsoletos os ponteiros arbitrários. E, se bem escrito, você se livra de uma tonelada de dados herdados que a maioria dos sistemas operacionais modernos atualmente possui.
No entanto, como desvantagem, você está muito mais distante do hardware e, como desenvolvedor, perde a capacidade de descer para um nível mais baixo de abstração e sujar as mãos.
Quais são suas opiniões sobre isso?
fonte
Respostas:
Eu acho que esse é outro caso em que "depende".
Se você está escrevendo aplicativos como navegadores da web, processadores de texto etc., onde o desempenho extremamente rápido não é necessariamente um problema, essa abordagem tem seus méritos. Ao usar essa abordagem, você pode oferecer a seus clientes uma experiência mais segura e controlada. Você não apenas limita os danos que podem ser causados por malware, mas também executa em um ambiente mais consistente.
É como a diferença entre jogos de console e jogos de PC. Os primeiros sabem exatamente com o hardware com o qual precisam trabalhar e podem usar esse conhecimento, enquanto os últimos precisam ser capazes de lidar com uma variedade maior de placas gráficas, placas de som, velocidades de disco rígido etc.
No entanto, haverá aplicativos (como jogos!) Que exigem acesso de baixo nível e ainda precisarão ser executados "nativamente".
Como os idiomas gerenciados, você terá que usar a ferramenta apropriada para o trabalho.
fonte
Geralmente, acho que é uma boa ideia, mas como não há muitos por perto ou quase totalmente assados, é muito difícil dizer como eles se sairiam no mundo real. Eu gostaria que a MS tivesse atualizado o projeto Singularity para que pudéssemos ver aonde isso estava indo, mas meu palpite é que parte dele está sendo trabalhada em alguma versão do Windows
fonte
Eu acho que os benefícios de um sistema operacional totalmente gerenciado são enormes e podem realmente ser o futuro, mas isso levará muitos anos.
Um bom sistema operacional gerenciado fornecerá a você todo o ponto de entrada gerenciado necessário para todas as tarefas de baixo nível, independentemente de ser gerenciado: capturar interrupções e executar E / S com dispositivos. O C # também permite código não seguro (lidando com ponteiros), mas será permitido apenas nos "drivers de dispositivo" (que serão apenas outro tipo de processo isolado por software).
Os benefícios em segurança, uniformidade, portabilidade e especialmente confiabilidade certamente excederão qualquer inconveniente de desempenho. Então, um sistema totalmente gerenciado é surpreendentemente rápido, pois não é mais necessário fazer a troca de contexto.
fonte
Os SOs gerenciados provavelmente são de alguma forma semelhantes aos microkernels - você sacrifica o desempenho em nome da segurança.
Pode haver problemas semelhantes, pois exige a divisão do código em 2 partes:
Dependendo do custo de entrada / saída da linguagem HL com segurança, ele pode impor problemas semelhantes aos microkernels - possivelmente um pouco mais rápido (deixar HL é mais rápido que a troca de contexto completo, mas o IIRC, por exemplo, o JNI é bastante caro).
O aplicativo do usuário provavelmente também precisaria de contextos separados, pois muitos aplicativos são gravados em outras plataformas (como C, Java ou .Net). Nos mesmos casos, os aplicativos podem ser vinculados à CPU (compiladores, conversores de música etc.) e precisam de otimização de assembler para funcionar com velocidade suficiente. Além disso - a proteção MMU implementada na linguagem HL provavelmente não será tão rápida quanto a do hardware, mesmo que possa ser muito mais ajustada.
Além disso, a linguagem HL não é proficiente nas operações de baixo nível. Embora o software geralmente seja projetado com drivers de boas práticas de codificação, não é necessário. Eu não acho que eles se protejam contra pelo menos alguns erros, pois os kernels às vezes exigem memória de gerenciamento manual.
Finalmente, não acho que esse sistema operacional exigiria VM completa. Como o sistema operacional não pode ser construído com o princípio, as linguagens HL de compilação, uma vez que são executadas em qualquer lugar (mesmo com a GC & Co.) seriam melhores candidatos.
O sistema operacional é inerentemente de baixo nível. Você passa para o hardware não apenas 'ponteiro arbitrário', mas provavelmente endereço físico e não virtual. Alguns DMA podem lidar apenas com os primeiros 16MiB de memória. Embora esse sistema operacional possa simplificar muito, ele não se livra dos endereços.
freedele quando o Windows realmente começou a liberar memória.Eu acho que ele ganhará popularidade na mesma época que os microkernels.
fonte
Pessoalmente, acho que a idéia de um sistema operacional gerenciado é um pouco como o comunismo: bom em teoria, mas impraticável de implementar.
O problema é que simplesmente não vejo nenhuma maneira de criar o sistema operacional gerenciado sem reescrevê-lo completamente do zero (e espero que alguém possa me provar que estou errado nessa parte). Além disso, como você encaixa décadas de código não gerenciado em um sistema operacional gerenciado?
Os núcleos dos sistemas operacionais mais populares do mercado são testados em batalha e amadureceram ao longo de algumas décadas. Você não as reescreve por capricho. Sem mencionar que a história está cheia de exemplos de projetos de processadores e arquiteturas de kernel que eram inegavelmente melhores, mas nunca foram capazes de convencer ninguém de que eles valiam o custo de mudar para eles.
Por fim, como uma empresa como a Microsoft ou a Apple vai vender um sistema operacional gerenciado para os clientes? O usuário médio do computador se importará se o sistema operacional é gerenciado ou não gerenciado?
O mencionado acima, espero que eu esteja errado e que os SOs gerenciados sejam uma realidade. Mas sou cético. Se o virmos, provavelmente não será por mais uma década ou duas.
fonte
O código gerenciado é apenas uma extrapolação do que a proteção de memória virtual compra hoje, a saber, a capacidade do computador de negar acesso a recursos.
A IBM já faz isso em seus sistemas de mainframe (eles chamam isso de outra coisa), portanto, na minha opinião, é apenas uma questão de tempo até que isso aconteça nos sistemas disponíveis para o público em geral.
Você se importaria se um laptop do Google (que executa o Chrome e basicamente nada mais) roda em código gerenciado ou não?
fonte
Isso não é verdade. No JNode, por exemplo, há uma
Unsafeclasse (e outras) que permite acessar locais de memória e assim por diante. Existem também algumas classes / métodos "mágicos" que são traduzidos em instruções privilegiadas pelo compilador JIT. O acesso a essas classes / métodos é (ou será) restrito pelo gerenciador de segurança, pelo compilador JIT e assim por diante. Mas se você estiver escrevendo um código que seja executado no nível do sistema operacional, esses recursos estarão disponíveis para você.A ressalva é (é claro) que o uso incorreto de
Unsafee classes relacionadas pode levar a falhas no sistema operacional imediatamente ou na pista.fonte
Duvido que sejam úteis para computadores de mesa. Mas o tempo pode me provar errado neste ponto.
Mas um potencial interessante aos meus olhos é como um sistema operacional de servidor, mais especificamente como um sistema operacional convidado em um ambiente virtualizado. Nunca foi correto instalar uma instalação completa do servidor Windows em um ambiente de servidor virtual, sabendo quantos serviços desnecessários são executados, incluindo a GUI completa.
Agora, instalar algo como Singularity em um servidor virtual para hospedar aplicativos ASP.NET, isso faz mais sentido. Supondo que eles possam manter um sistema operacional leve.
fonte