Translate

Mostrar mensagens com a etiqueta Memoria. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Memoria. Mostrar todas as mensagens

sábado, 21 de fevereiro de 2026

📊 Da Era dos 16MB ao Infinito: A Linha do Tempo que Explica 24 → 31 → 64 bits no Mainframe

 

Bellacosa Mainframe explica o endereçamento de memoria no IBM Mainframe 24 31 e 64 bits

📊 “Da Era dos 16MB ao Infinito: A Linha do Tempo que Explica 24 → 31 → 64 bits no Mainframe”

Prepare-se, padawan… agora você vai enxergar a evolução do mainframe como um verdadeiro mapa de poder computacional — cada salto não foi só técnico… foi uma jogada estratégica digna de xadrez. ♟️


🟢 1. Era 24 bits — O Mundo Cabia em 16MB

🔹 Contexto

  • Arquitetura do OS/360
  • Endereçamento: 24 bits
  • Limite: 16 MB

🧠 O que isso significava?

  • Tudo precisava caber em um espaço minúsculo
  • Programas eram ultra otimizados
  • Overlays eram comuns (carregar partes do programa sob demanda)

💬 Bellacosa insight:

“Aqui nasceu o DNA da eficiência — cada byte valia ouro.”


🟡 2. Era 31 bits — O Hack Mais Elegante da História

🔹 Contexto

  • Evolução para o MVS
  • Introdução da System/370-XA

⚙️ O que mudou?

  • Endereçamento: 31 bits (não 32!)
  • Limite: 2 GB
  • 1 bit reservado (bit 0) para controle

🔥 O pulo do gato:

  • Compatibilidade TOTAL com 24 bits
  • Mistura de modos (24 + 31)
  • Controle inteligente via bit mais significativo

🧪 Conceito-chave:

O endereço não é só endereço — ele carrega “intenção”

💬 Bellacosa insight:

“Enquanto o mundo queria mais bits… o mainframe queria mais inteligência.”


🔵 3. Era 64 bits — O Universo Expandido

🔹 Contexto

  • Arquitetura moderna: z/Architecture
  • Sistemas como z/OS

🚀 O que mudou?

  • Endereçamento: 64 bits
  • Limite teórico: exabytes
  • Espaço virtual gigantesco

🧠 Novos conceitos:

  • Above the bar / below the bar
  • Memory objects
  • Large memory exploitation

💬 Bellacosa insight:

“Agora não é mais sobre caber… é sobre escalar sem limites.”


📊 Timeline Simplificada (Estilo Raiz)

1970s ───────────────► 24 bits (16 MB)
OS/360

1980s ───────────────► 31 bits (2 GB)
MVS / System/370-XA
(bit 0 reservado 👀)

2000+ ───────────────► 64 bits (exabytes)
z/Architecture / z/OS

🧬 Conexão Evolutiva (O Segredo por Trás)

EraProblemaSoluçãoFilosofia
24 bitsMemória limitadaOtimização extrema“Faça caber”
31 bitsCrescer sem quebrarBit de controle“Evolua com legado”
64 bitsEscalabilidadeEspaço massivo“Expanda sem limites”

🐣 Easter Egg de Mestre

Mesmo no mundo 64 bits…

👉 O conceito de “compatibilidade com legado” continua vivo
👉 E o espírito do bit 0 ainda ecoa nas decisões de design

💥 Ou seja:

O passado do mainframe nunca foi descartado — ele foi incorporado


⚡ Fechamento Estilo Bellacosa

Se você entendeu essa timeline, você desbloqueou algo raro:

🧠 Você não vê mais bits… você vê decisões arquiteturais

Porque no mainframe:

Cada bit tem história
Cada limitação vira estratégia
E cada evolução respeita o passado

 

segunda-feira, 11 de agosto de 2025

Programa COBOL usando ponteiro de memória

 

Programa COBOL usando ponteiro de memória

4,424 followers

Salve jovem padawan, nesta inspirada sexta-feira resolvi explorar um tema um pouco mais complexo.

Em minhas aulas sinto uma certa dificuldade em apresentar o tema, às vezes, a explicação acaba confundindo ainda mais. Por isso nada melhor que colocarmos a mão na massa, digo no teclado.

Relebrando conceitos

SET - O comando SET designa um valor para uma referência COBOL.

ADDRESS - Método simples de obter capacidade de endereçamento para áreas de dados de memoria definidas na LINKAGE SECTION usando variáveis de ponteiro e o registro especial ADDRESS

Programa COBOL120.

O programa COBOL120 é bem interessante, no DATA DIVISION teremos duas áreas de memórias distintas:


  1. Working Storage Section
  2. Linkage Section


As variáveis na Working são do gênero Grupo com 4 variáveis do tipo string e inicializadas com valores. Um ponteiro de memória e um índice contador.

Na Linkage temos uma Tabela interna com string de 4 bytes e com 4 ocorrências.

Processamento

O código é simples, contem alguns displays, dois laço Perform Varying e comandos SET e Address of, para capturar o endereço da memória e alocar na nova variáveis. Ao final faço novo display mostrando a tabela inicializada sem MOVE/ACCEPT/REDEFINES.

 *****************************************************************
      * DATA     : 06/09/2024
      * AUTOR    : VAGNER RENATO BELLACOSA
      * OBJETIVO : PROGRAMA EXEMPLO ARQUIVO QSAM LOOP
      * USO DE ENDERECO DE MEMORIA E TABELA INTERNA
      * USO DE ALOCACAO DINAMICA
      * CPD      : INEFE
      *****************************************************************
       IDENTIFICATION DIVISION.
      *************************
       PROGRAM-ID. COBOL120.
       AUTHOR. VAGNER BELLACOSA.
       DATE-WRITTEN. 06/09/24 @ 21:18:00.
       DATE-COMPILED. 2024-09-06.
       SECURITY. TESTE INEFE
       INSTALLATION. INEFE MARIST

      **********************
       ENVIRONMENT DIVISION.
      **********************
      *
       CONFIGURATION SECTION.
      *
       SOURCE-COMPUTER. IBM-I.
       OBJECT-COMPUTER. IBM-I.
       SPECIAL-NAMES. DECIMAL-POINT IS COMMA.
      *
       INPUT-OUTPUT SECTION.
      *

      ***************
       DATA DIVISION.
      ***************
      *
       WORKING-STORAGE  SECTION.
      *
       01 WORK-AREA.
        05 WSS-DATA1           PIC X(4) VALUE 'AAAA'.
        05 WSS-DATA2           PIC X(4) VALUE 'BBBB'.
        05 WSS-DATA3           PIC X(4) VALUE 'CCCC'.
        05 WSS-DATA4           PIC X(4) VALUE 'ZZZZ'.
      *
       77 WSS-PTR POINTER.
       77 WSS-IDX              PIC 9.
      *
       LINKAGE SECTION.
      *
       01 TBL-DATA.
        05 TBL-DATA-ALPHA      PIC X(4) OCCURS 4 TIMES.
      *
      ********************
       PROCEDURE DIVISION.                                              00210000
      ********************

           DISPLAY ' '
           DISPLAY ' '
           DISPLAY ' COBOL120'
           DISPLAY ' USO DE TABELA INTERNA E MOVIMENTACAO POR PONTEIRO'
           DISPLAY ' DE MEMORIA.'
           DISPLAY ' '

      *
           DISPLAY ' TABELA INICIAL - VAZIA'.
           DISPLAY ' '.

           PERFORM VARYING WSS-IDX FROM 1 BY 1
                                 UNTIL WSS-IDX > 4
             DISPLAY ' TBL-DATA-ALPHA [' WSS-IDX '] = '
                       TBL-DATA-ALPHA(WSS-IDX)
           END-PERFORM.

           DISPLAY ' '.

      *
           SET WSS-PTR TO ADDRESS OF WORK-AREA.
           SET ADDRESS OF TBL-DATA TO WSS-PTR.
      *
           DISPLAY ' RECEBI O MESMO ENDERECO DA WORKING'
           DISPLAY ' TABELA INTERNA INICIALIZADA PELO ADDRESS E SET'
           DISPLAY ' '.

           PERFORM VARYING WSS-IDX FROM 1 BY 1
                                 UNTIL WSS-IDX > 4
             DISPLAY ' TBL-DATA-ALPHA [' WSS-IDX '] = '
                       TBL-DATA-ALPHA(WSS-IDX)
           END-PERFORM.

           DISPLAY ' '.

           STOP RUN.

       END PROGRAM COBOL120.
      ********************** FIM PROGRAMA   **************************** 

Como funciona.


Article content


  • SET WSS-PTR TO ADDRESS OF WORK-AREA.


O comando acima obtém o ponteiro de memória da WORK-AREA e aloca na variável WSS-PTR.


  • SET ADDRESS OF TBL-DATA TO WSS-PTR.


No segundo comando SET ADDRESS atribui o endereço do ponteiro na tabela TBL-DATA, que a partir de agora tem o mesmo conteúdo das variáveis.


Article content
 PERFORM VARYING WSS-IDX FROM 1 BY 1
                                 UNTIL WSS-IDX > 4
             DISPLAY ' TBL-DATA-ALPHA [' WSS-IDX '] = '
                       TBL-DATA-ALPHA(WSS-IDX)
           END-PERFORM.

Esse laço lista todas as ocorrencias da Tabela Interna na Sysout.

Espero ter ajudado.


sábado, 2 de agosto de 2025

Boas Praticas em Performance e otimização uma primeira olhada.

 

Boas Praticas em Performance e otimização uma primeira olhada.

4,424 followers

Falando sobre performance e otimização.

Salve jovem padawan, no artigo de hoje conversemos sobre um assunto pantanoso, que derruba 7 em 10 programadores, estou falando de performance e otimização de programas, infelizmente a pressa é inimiga da perfeição.

Como veremos no decorrer do artigo, o grande problema sempre é o fator tempo, somos todos coelhos da Alice: atrasados e fugindo da Rainha Louca, ops Rainha de Copas e no final quem paga é o programa implementado na máxima velocidade de desenvolvimento dentro possível, com uma qualidade mediana, atendendo o MVP.


Pense antes de codificar

Rascunhe seu programa em lápis e papel, desta forma consegue ter uma visão do todo, uma noção do caminho crítico e para o teste de mesa, num primeiro momento consegue-se visualizar pontos passiveis de melhoria e pontos onde o programa não se comporta da maneira espera.

Existem inúmeras ferramentas visuais no mercado, que auxiliam na depuração calculando o uso de memória, uso de CPU e gargalos do sistema, para o ambiente Mainframe existe o Omegamon e o APA. Ferramentas que em seus relatórios apresentam estatísticas fabulosas sobre os problemas encontrado no código, pontos de gargalo e tempo de execução.


Uso de memória

Cuidado ao codificar, não crie variáveis em excesso, lembre-se sempre de inicializar as variáveis no princípio do código, desta forma economizam-se ciclos de CPU gastos desnecessariamente, forçando paradas no processamento para inicializar as variáveis. Lembre-se I/O seja em acessos a discos e sub-programas externo estouram o Time.

Cuidado ao utilizar arrays e vetores, pois ao criar grandes tabelas internas estará consumindo memoria desnecessariamente e prejudicara o bom funcionamento do seu programa, principalmente em escala, quantos mais usuários maior queda de performance.

Verifique as variáveis não utilizadas, que gastam espaço em memória, pense num programa utilizado por milhares de usuários, com centenas de milhares de requisição, ao final de um ano, quanto de memória poderia ter sido economizado, quanto de processamento ou ciclos de CPU, gasto em gerenciamento de memória desnecessário. Imagine a pegada ecológica, gasto de eletricidade e CO2 liberado.


Ciclos de CPU

A pressa é inimiga da perfeição, muitas vezes criamos logica em que o programa consome desnecessariamente processamento, movendo variáveis semi-utilizadas ou mesmo sem nenhuma utilização, atente-se a código morto e rotinas que entram e saem sem agregar nenhum valor ao processo.

Pense no custo em CPU de chamadas repetida a functions, arrow-functions e programas externo, a cada parada de processo e pulo para outro programa e o próprio retorno ao programa chamador.

Trabalhe apenas com os campos da tabela que serão utilizados em outputs ou cálculos, o trafego de dados além da memória, gera gasto de CPU indevidos. Muitas vezes é mais produtivo, usar arquivo sequencial da tabela, através de unload, usar aplicativos específicos para ETL, a exemplo SORT do Mainframe.


Espaço em Disco

Em tempos de cloud computer e processamento distribuído, desvalorizávamos o impacto do processamento, em gravar dados desnecessariamente em disco, informações que nunca serão utilizadas e degradam o ambiente, obrigando a adquirir mais e mais espaço em disco.

Fazendo o programa perder milissegundos cruciais na busca da informação num disco imenso e cada vez mais abarrotado, uma política de dados é importante para evitar esse viés.


Os perigos de laços estilo While

Quando codificar While cuidado com os laços infinitos. Às vezes um teste de mesa incompleto deixa uma situação onde o FLAG de saída, pode parecer obvio, mas grandes programadores caíram em situação semelhante, um IF mal planejado e um FLAG descontrolado e surge o caos, com looping infinito ou anomalias de difícil reprodução.


Os perigos de laço estilo FOR

O perigo do FOR não é tão drástico quanto o While, mas devido a sua quantidade de uso é muito prejudicial a longo prazo, obrigando a aquisição de mais hardware inutilmente, uma solução bem simples é sair do laço assim que a solução for encontrada.


Os perigos de IF inúteis

Muitas vezes o programador está cheio de boas intenções e cria uma sequência sem fim de IFs. Mas para garantir a qualidade dos dados e o controle de fluxo do programa, porem muitas vezes são desnecessários, procure pensar numa lógica do IF master e somente se ele funciona gerar os outros testes em IF, quanto menos paradas para decisão mais performático e melhor será seu programa.

Use comandos em estilo EVALUATE, SWITCH para um controle de fluxo mais eficiente e atente-se a não usar ELSEs em demasia, dificultam muito a análise e ajudam a gerar erros de simpatia, pois às vezes confundimos o lugar do ELSE e no teste pulamos o IF.

Outro grande problema e a quantidade de paradas no processamento, obrigando o programa a funcionar como conta gostas.


Espionando programas em Mainframe

Como disse anteriormente existem algumas ferramentas fabulosas em ambiente Z/OS, o OMEGAMON e o APA monitoram e acompanham a performance de programas em ambiente Mainframe, indicando os custos de CPU / Memória e rotinas em looping e consumos/acessos diversos. Vale a pena conhecer o manual técnico e explorar esta ferramenta.

Em banco de dados DB2 existe o comando Explain que gera estatísticas de acesso e caminhos para melhorias tais como criar índices, reorg de tabelas, partição de ambientes e etc, auxiliando o DEV a criar querys mais performáticas.


Conclusão

Caro padawan, reconheço que fui superficial e que deixei pontos a esclarecer, mas o objetivo deste artigo. Foi fazê-lo pensar, a ter cuidado quando codifica, apesar das máquinas terem caído o custo, em quantidade, o uso de memória e CPU desnecessário tiram a competitividade da empresa, gerando custos ocultos e gerando prejuízos a longo prazo.

Como exercício de imaginação, pense um Banco com milhares de agências e milhões de clientes, usando os serviços 24 horas por dia, 7 dias por semana e 365 dias no ano. Quanto custara ao final do ano alguns IFs desnecessários e 2 segundos desperdiçados em loops inúteis?

Por isso pense bem ao codificar, faça teste de mesa, use papel e lápis para ajudar em seu trabalho, verifique os IF e loopings, não use campos de tabelas desnecessariamente e boa sorte.

Espero ter ajudado. Bom curso a todos.


Article content


Article content

Mais momento jabá, quem diria que já passou retrospectiva do meu 44° aniversario, tantas aventuras, tantos momentos únicos, memórias em imagens de momentos mágicos da vida do Tiozão visite meu vídeo e veja para onde fui desta vez: https://www.youtube.com/watch?v=sBgA0nvtpdU


Bom curso a todos.

Article content

https://www.linkedin.com/in/vagnerbellacosa/


Article content

https://github.com/VagnerBellacosa/

Pode me dar uma ajudinha no YouTube?

Article content

https://www.youtube.com/user/vagnerbellacosa