TODO

Correções até o momento
=======================

1. Mostrar Broker Locais no MPS (listar sob qual broker global cada local está situado)
2. Arrumar parâmetro IP do MPS em Global Brokers (está aparecendo nome da máquina ao invés do IP)
3. Se um Broker Local morre ou sai de execução seu global continua com ele na lista (corrigir)
4. Há sleeps dentro de algumas classes (tal como a de atualização de cargas) - crie parâmetros para quantificar o tempo desses sleeps dentro dos arquivos de configuração.

Outros:
=======

1. Montar uma estrutura de experimentos contendo:
- 2 globais (total 2)
- 2 locais debaixo de cada global (total 4)
- 2 schedulers debaixo de cada global (total 8)
2. Fazer experimentos utilizando os programas:
- tabuada
- mutex (modificado - retirar o while (1))
3. Documentar todo o código (todos os métodos e funções de todos os programas (mesmo aqueles que vc não fez, tal como IBL, RouteGA e Monitores) -> O que não souber pode perguntar para mim ou Evgueni
4. Gerar com DOXYGEN a documentação de tudo e disponibilizar no MidHPC @ sourceforge.net
5. Tentar resolver problema de Scheduler que é morto devido ao Cryopid (provavelmente da forma que te pedi para executar usando Bash)
6. O problema do Monitor de processos será resolvido depois *** (Deixar no TODO)
7. Montar uma estrutura com README, Changelog, Makefile, TODO e INSTALL para cada uma das ferramentas (mesmo monitores, IBL etc) e escrever tudo que puder dentro do TODO e INSTALL de cada ferramenta (INSTALL? Mas já não será instalada por padrão? sim... ms vale a pena descrever um pouco sobre o funcionamento e interações com outros programaS)
8. Fazer um README, TODO, INSTALL, Makefile geral para todas as ferramentas. Quando esse Makefile for ativado ele faz o make dos demais :)
9. Montar um HTML em inglês contendo detalhes tais como (usar esse HTML para chamar as documentações geradas com DOXYGEN - é bem legal usar figuras aqui. Uma figura de todo um ambiente com os elementos e onde o usuário possa clicar e saber mais de cada módulo. Saber mais, por exemplo do monitor de processos, ou do monitor de sistema, ou do Scheduler e por ai vai... acho que uma estrutura de rede para isso seria bem legal e em cada máquina camadas com os nomes de cada programa ou módulo que é rodado - Não se esqueça que isso deve ser a index.html que chama as outras documentações - colocar isso no MidHPC @ Sourceforge.net antes de nossa reunião):
- quem comunica com quem? que programa chama qual programa? como um programa usa as saídas de outro? (Por exemplo: como o Scheduler usa as saídas do IBL? e assim por diante)
- o fluxo de mensagens para iniciar uma aplicação (passando pelo primario global, etc... até ser executada - IBL, RouteGA, checkpoitn etc)
- quais as entradas e saídas de cada programa no MidHPC? Exemplos das entradas e saídas (exemplo dos XMLs etc)
10. Após cumprir todas essas etapas: marcar uma reunião (tendo todo o ambiente pronto - todos itens anteriores prontos) para eu checar a execução. Portanto essa reunião é de conclusão. Eventualmente demais itens de correção no código ou documentação serão levantados.

Detailing item 5.2.5

1 - Scheduler passes the username, program file (including path) and program parameters to IBL and executes IBL for each one of the means and standard deviations
2 - Scheduler grabs all the information from IBL executions and stores them in a XML file using the following format: <table-column-name></table-column-name> (for instance <bytes_in_avg>22.2</bytes_in_avg>) DON'T FORGET TO INCLUDE MEANS AND STANDARD DEVIATIONS
3 - Scheduler gets means and standard deviations from the table application for each process running in the environment (you can add a column in the table application with the application status: Running or Finished) and makes a select in the table process to count how many processes compose each running application. The Scheduler also gets where (computer_id from table computer) each process is running.
4 - Scheduler carries on generating the XML file using the information obtained from the tables application and process. The scheduler will generate something like (the same for the new application presented in the item 2 in this post):

<application gid="1">
<number_of_processes>4</number_of_processes>
<scheduled>
<process>0</process> ### notice the id inside this XML tag is the computer_id
<process>1</process> ### which defines where a certain process is running
<process>8</process>
<process>15</process>
</scheduled>
<bytes_in_avg>22.2</bytes_in_avg>
...
</application>

PS: The new application that has just started will also have the tag <scheduled> and <process> inside it, although the tags <process> will have the name computer_id, which is the id of the Scheduler which started the application.

5 - After generating all the means and standard deviations in the XML file (for each application) the Scheduler have to get the capacity of each computer in the environment. The table computer could have all the information about MIPS capacity, HD read-write throughput and Memory latency coeficients (2 for the main memory usage and 3 for the swap memory usage).
Getting such information from the table computer, the Scheduler must fill the XML file in the following way:

<computers>
<computer>
<mips>1000</mips>
<hd_read_throughput>10.2</hd_read_throughput>
<hd_write_throughput>8.7</hd_write_throughput>
<main_memory_coeficient_a>10.2</main_memory_coeficient_a>
<main_memory_coeficient_b>10.2</main_memory_coeficient_b>
<swap_memory_coeficient_a>10.2</swap_memory_coeficient_a>
<swap_memory_coeficient_b>10.2</swap_memory_coeficient_b>
<swap_memory_coeficient_c>10.2</swap_memory_coeficient_c>
</computer>
... # other computers in here
</computers>

6 - Now you make a simple program to convert the XML to the alloc.file format used by RouteGA
7 - Scheduler launches the conversion program and, then, calls RouteGA
8 - The RouteGA output is used by the Scheduler

New Task - Network latency

There is a new task:

9- Measure Network latency.
Mandatory: Global Brokers should exchange messages in order to calculate the network latency between them. This may be done by using a udp request or by ping:
'ping -c $1 141.109.37.173 | tail -1 | cut -d = -f 2 | tr -d ms | tr -d " " | cut -d \/ -f 2'

Wish list:
Add bandwidth measures between Local Broker and the Global Broker and between the Local Broker and the Scheduler.
This way, it is possible to extract measures that represents all computers in the Grid environment.