Compilando Nodes como Aplicações de Console

Neste tópico discutimos detalhes e diferenças técnicas entre criar seus Nodes uniGUI como aplicações console versus criá-los como aplicações desktop (GUI).

Aplicações Windows GUI

Essas aplicações são projetadas para rodar como aplicações desktop GUI com um ou vários formulários. Todas as aplicações Delphi VCL estão nesta categoria.

Todas as aplicações uniGUI que são criadas como Standalone Server project são também aplicações Windows GUI.

Veja também: Standalone Server

Aplicações Windows Console

Essas aplicações normalmente não deployam formulários. Elas vêm com uma janela de console que é usada para interagir com o usuário por meio de um prompt de linha de comando. Todas as aplicações uniGUI que são criadas como Standalone Server (Console Application) são tecnicamente aplicações Windows Console.

Quais são as diferenças?

Se você está usando Standalone Server para fins de depuração ou implantação em desktop, não há diferenças significativas entre eles. Você pode criar sua aplicação tanto como Standalone Server Project ou Standalone Server (Console Application) e obterá os mesmos resultados.

Implantação como HyperServer Nodes

Standalone Servers também são usados para implantação como HyperServer Nodes. Se você planeja executar suas aplicações sob uniGUI HyperServer você deve criá-las e executá-las como aplicações Standalone Server.

Nesse caso há uma diferença importante entre criar sua aplicação como aplicação Windows GUI ou Windows Console. Para entender melhor isso, primeiro precisamos nos familiarizar com o Windows Desktop Heap.

Windows Desktop Heap

Desktop Heap é um espaço de memória que o Windows usa para armazenar vários objetos de interface do usuário. Este é um espaço de memória limitado que está disponível por sessão, onde uma sessão representa o ambiente de logon de um único usuário. Quando um novo executável é iniciado, uma certa quantidade desse espaço de heap é reservada/ocupada para esse novo executável. Logicamente, isso limita o número máximo de aplicações executáveis que podem ser iniciadas por sessão. Quando esse limite é atingido, o Windows se recusará a iniciar mais aplicações e terminará aplicativos silenciosamente antes que se tornem ativos, deixando uma entrada de registro de erro nos logs de aplicação do Visualizador de Eventos do Windows.

Aplicativos desktop consomem consideravelmente mais espaço do Windows Desktop Heap em comparação com aplicativos console. Isso significa que o número máximo de aplicações que podem rodar simultaneamente será menor se elas forem compiladas como aplicações desktop. Por outro lado, esse número aumenta significativamente se as mesmas aplicações forem compiladas como aplicações console.

Não existe um número exato documentado de bytes consumidos do Desktop Heap por processo, mas testes indicam que mesmo o aplicativo uniGUI mais básico compilado como aplicativo desktop alcançará o limite do Desktop Heap após algumas centenas de instâncias. Aplicações compiladas como console não são afetadas pelo limite do Desktop Heap; seu número máximo é primariamente limitado pela memória física disponível. Em um teste extremo, mais de 10.000 aplicações console (HyperServer Nodes) foram iniciadas em um sistema com 64 GB de RAM, demonstrando que aplicações console evitam a limitação do Desktop Heap.

Veja também: Visão geral do Desktop Heap

Como isso se relaciona com o uniGUI HyperServer

O uniGUI HyperServer inicia múltiplas instâncias da mesma aplicação uniGUI chamadas Nodes. Como o Windows Desktop Heap limita o número de subprocessos que podem ser iniciados em uma sessão do Windows, para maximizar a escalabilidade você deve criar suas aplicações uniGUI como aplicações console (ou converter as existentes) para que o limite do Desktop Heap não seja alcançado.

Veja também: Maximizando a escalabilidade do HyperServer

Convertendo aplicações Standalone Server existentes para aplicações Console

Se você quiser converter aplicações standalone server existentes para aplicações console, siga os procedimentos para seu ambiente de desenvolvimento.

1

Delphi

Para um projeto Delphi, a única diferença entre um app uniGUI standalone desktop server e um app console server é a diretiva do compilador APPTYPE:

Adicione a diretiva {$APPTYPE CONSOLE} ao seu arquivo .dpr e reconstrua sua aplicação.

Exemplo:

Project1.dpr

program Project1;

{$APPTYPE CONSOLE}

uses
  Forms,
  ServerModule in 'ServerModule.pas' {UniServerModule: TUniGUIServerModule},
  MainModule in 'MainModule.pas' {UniMainModule: TUniGUIMainModule},
  Main in 'Main.pas' {MainForm: TUniForm};

{$R *.res}

begin
  ReportMemoryLeaksOnShutdown := True;
  Application.Initialize;
  TUniServerModule.Create(Application);
  Application.Run;
end.

Adicionar a diretiva do compilador e reconstruir é suficiente para converter um aplicativo standalone em uma aplicação console.

2

C++ Builder

Converter um app desktop C++ Builder para um app console é menos direto do que em Delphi. Você pode criar um novo app console e mover seus formulários e módulos para ele, ou editar seu arquivo CPP do projeto e fazer as modificações necessárias.

Alterações típicas incluem:

• Mudar o procedimento main do Windows de: int WINAPI_tWinMain(HINSTANCE, HINSTANCE, LPSTR, int) para: int_tmain(int argc, _TCHAR* argv[])

• Adicionar o cabeçalho <tchar.h> se estiver ausente.

Arquivo de projeto de exemplo:

Project1.cpp

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <tchar.h>
#include <UniGUIVars.hpp>

USEFORM("ServerModule.cpp", UniServerModule); /* TUniGUIServerModule: File Type */
USEFORM("MainModule.cpp", UniMainModule);     /* TUniGUIMainModule: File Type */
USEFORM("Main.cpp", MainForm);                /* TUniForm: File Type */
//---------------------------------------------------------------------------

#ifdef _WIN64
#pragma link "UniGUIVars.o"
#else
#pragma link "UniGUIVars.obj"
#endif

#pragma Project1
//---------------------------------------------------------------------------

int_tmain(int argc, _TCHAR* argv[])
{
  ReportMemoryLeaksOnShutdown = true;
  try
  {
    Forms::Application->Initialize();
    Uniguivars::CreateServerModule(__classid(TUniServerModule));
    Forms::Application->Run();
  }
  catch(Exception &exception)
  {
  }
  return 0;
}
//---------------------------------------------------------------------------

Essas mudanças devem ser suficientes para realizar a conversão, embora criar um novo projeto console e mover units/formulários às vezes possa ser mais fácil dependendo da complexidade do projeto.