Portions of code containing critical code routines are identified and
labeled, then compiled into Dynamic Link Libraries ("DLLs") and linked
such that the critical code routines are optimally loaded into a reserved
address space in the DLL memory space. If supported, cache locking may be
enabled for the reserved address space. The portions of source code
containing portions of critical code for which execution performance is to
be improved are labeled, and the source code is scanned prior to
compilation to locate the labeled portions of critical code. A linker is
configured to store all the labeled portions of critical code into an
Executable and Linking Format ("ELF") section header, which is relocated
at run-time into a memory space reserved for the portions of critical
code. Alternatively, the critical code is compiled and linked into an
executable file containing the critical code, and the executable file is
optimized by scanning the instruction stream and in-lining the critical
code. A prolog and an epilog that accommodates this in-lined critical code
is generated, and a single optimized DLL containing the critical code is
generated, which is then loaded into a reserved memory space. Robust fault
containment is facilitated through the use of code modules implemented as
shared libraries that can be loaded and unloaded in a running system by
individual processes. These code modules can be replaced individually as
defects are found and fixed without requiring replacement of the entire
system image or application image. What would normally be a monolithic
application is modularized, and the sharing of common code among multiple
applications is facilitated.
As parcelas do código que contêm rotinas críticas do código são identificadas e etiquetadas, compiladas então em bibliotecas de ligação dinâmicas ("DLLs") e ligadas tais que as rotinas críticas do código estão carregadas optimally em um espaço de endereço reserved no espaço de memória do DLL. Se suportado, travar do esconderijo pode ser permitido para o espaço de endereço reserved. As parcelas do código de fonte que contêm as parcelas do código crítico para que o desempenho da execução deve ser melhorado são etiquetadas, e o código de fonte são feitas a varredura antes da compilação para ficar as parcelas etiquetadas do código crítico. Um linker é configurarado para armazenar todas as parcelas etiquetadas do código crítico em um encabeçamento de seção executável e ligando do formato ("DUENDE"), que relocated no run-time em um espaço de memória reservado para as parcelas do código crítico. Alternativamente, o código crítico é compilado e ligado em uma lima executável que contem o código crítico, e a lima executável optimized fazendo a varredura do córrego e do em-forro da instrução o código crítico. Um prolog e um epilog que acomode este código crítico em-alinhado são gerados, e um único DLL optimized que contem o código crítico são gerados, que é carregado então em um espaço de memória reserved. O containment robust da falha é facilitado com o uso dos módulos do código executados como as bibliotecas compartilhadas que podem ser carregadas e descarregado em um sistema running por processos individuais. Estes módulos do código podem ser substituídos individualmente enquanto os defeitos são encontrados e reparados sem reque a recolocação da imagem inteira do sistema ou da imagem da aplicação. O que seria normalmente uma aplicação monolítica é modularized, e compartilhar do código comum entre aplicações múltiplas é facilitado.
