“As a matter of fact, we don’t fully understand it ourselves. We obey.” Oh, I get it. In the sequel, he’s reincarnated as Sam Altman. #FuckAI #Monsterdon #TheHauntedPalace #DelayedWatch
Search
38 results for “Assam_in_china”
-
Fox News - Breaking News Updates | Latest News Headlines | Photos & News Video [Unofficial] @[email protected]Seattle Seahawks dominate Chiefs 20-3 as Sam Darnold silences critics in potential Super Bowl preview
-
Clinical performance and decision thresholds of an automated plasma p-tau217 assay for amyloid pathology in a Taiwanese memory clinic.
J Neurol. 2026 Oct 21;273(11)Authors: Lin YS, Tsai MJ, Lai CL, Ho HL, Fuh JLPubMed: 42905283Submit Comment
Read more: https://www.alzforum.org/papers/clinical-performance-and-decision-thresholds-automated-plasma-p-tau217-assay-amyloid
#Dementia #Alzheimers #Autism #Caregiving -
de avond valt in #Westeremden -en — Evening falls in Westeremden fr — Le soir tombe sur Westeremden de — Der Abend bricht an in Westeremden es — La tarde cae en Westeremden it — La sera cala su Westeremden pt — A noite cai sobre Westeremden pl — Wieczór zapada w Westeremden sv — Kvällen faller över Westeremden da — Aftenen falder på i Westeremden no — Kvelden faller på i Westeremden el — Το βράδυ πέφτει στο Westeremden tr — Akşam Westeremden'e iniyor cs — Večer klesá na Westeremden ro — Seara se lasă peste Westeremden hu — Estét hull Westeremdenre fi — Ilta laskeutuu Westeremdeniin - #fotografie #photography #landscapePhotography #NL #Groningen #naturePhotography *edited in #ON1 Photo RAW MAX & #NoNoise 2027 *
-
Hawari: Syria could lose a century without guaranteed rights
The transitional administration established in Syria following the overthrow of Bashar al-Assad’s government faces fundamental challenges, including political…
#Conflict #Conflicts #War #Syria
https://www.europesays.com/3328932/ -
Syria’s first DNA-based identifications offer hope for families of the missing
Damascus, SyriaReuters DNA testing has helped identify the remains of missing people in at least three cases in…
#EuropeSays #Headlines #News #Europe #Europa #EU #Syria #Basharal-Assad #dna #ICRC #InternationalCommitteeoftheRedCross #missingpeopleinSyria #Raqqa #SyriaJusticeandAccountabilityCentre
https://www.europesays.com/iran/340499/ -
This creates a new problem to solve. The biggest way to increase the likelihood of solo success is not to add a cofounder of convenience—it's to surround yourself with resources and other solo founders so you can build "solo, together." In a world of increased automation, building a solo company will be more viable than ever, but that doesn’t mean you have to build totally alone.
-
Personal technology companies seem to just have one mantra, let’s extract as much revenue and keep our customers hooked as much as humanly possible. I know this is capitalism 101 but I’ve had enough.
https://ljpuk.net/posts/its-getting-harder-to-find-the-fun-in-technology
-
I so love tea. (obligatory link to something funny: https://www.youtube.com/watch?v=eELH0ivexKA&list=RDeELH0ivexKA&start_radio=1) with the sole exception of my own father, who likes coffee, every guest i've ever had have agreed to a cup of tea. loose leafs survive many years. older leafs simply require a bit longer infusion. also, assam and yunnan are always good signs with tea. surprisingly, anything that comes from Ceylon tends to be very good.
-
Veja a letra da música “Assim seja” de Pentágono
#Pentágono #AssimSeja
https://daletra.com.br/pentagono/letra/assim-seja.html -
E que o Brasil continue assim, com mais integração, mais educação para os jovens e as nossas crianças, mais respeito.
#Eleicoes2026 #Brasil #Lula #FlavioBolsonaro
#Bolsonaro #Soberania #Democracy #Democracia -
https://www.europesays.com/iran/342362/ Syria arrests Assad’s cousin and senior former regime officers #BasharAlAssad #PostAssadSyria #Syria
-
Bolsonaro já não vai pedir anulação das eleições e assumiu-se como líder da oposição. Ainda assim, vai pedir invalidação da candidatura de Lula por “abuso de poder”.
https://www.publico.pt/2026/10/27/mundo/noticia/partido-flavio-bolsonaro-reconhece-vitoria-lula-silva-2192739 #notícias -
Nessa Playlist temos diversos artistas apoiadores dos presidente Lula.
Basta passarem para o próximo vídeo assim que terminar o primeiro.
Ou ativem a AUTOREPRODUÇÃO.É o filme dos brasileiros essa madrugada.
Vamos amolecer esses corações duros...Nós precisamos de VOCÊ 👈️️️️️️️️️️, que não foi votar no primeiro turno, VOCÊ FARÁ A DIFERENÇA.
PlayList:
URL: https://clip.place/my-library/video-playlists/igot1LnoLoZbpMsGK3BaC9#SoberaniaDigital #Democracy #Democracia #Soberania #Eleicoes2026 #Lula #FlávioBolsonaro
-
https://www.europesays.com/ro/344492/ Live Video&Text | Sepsi – Universitatea Craiova 0-2, ACUM, DGS 1. Gool! A marcat și Assad #Craiova #Liga1 #RO #Română #Romania #Romanian #Sepsi #SepsiCraiova #Sport #Sports #superliga #UniversitateaCraiova
-
Lula passou adiante e a margem de diferença continua a subir...
o icl já dá a vitória a Lula....
que assim seja.... #Lula13
-
Que porra foi essa de votar até 7 da noite?
O que aconteceu de verdade? Teve ciclone em algum Estado ou algo assim?
-
🚨New ransom group blog posts!🚨
Group name: bravox
Post title: Barrow & Grimm 🇺🇸
Organization: Barrow & Grimm
Location: 🇺🇸 US
Sector: Legal
Info: https://cti.fyi/#disclosure/bravox/Barrow%20%26%20Grimm%20%F0%9F%87%BA%F0%9F%87%B8Group name: bravox
Post title: AMSAM 🇫🇷
Organization: AMSAM
Location: 🇫🇷 FR
Info: https://cti.fyi/#disclosure/bravox/AMSAM%20%F0%9F%87%AB%F0%9F%87%B7Group name: N0n
Post title: Andrews Advisory Group LLC
Location: 🇺🇸 US
Sector: Financial Services
Info: https://cti.fyi/#disclosure/N0n/Andrews%20Advisory%20Group%20LLCGroup name: N0n
Post title: Keidel Supply Company Incorporated
Location: 🇺🇸 US
Sector: Other
Info: https://cti.fyi/#disclosure/N0n/Keidel%20Supply%20Company%20IncorporatedGroup name: N0n
Post title: Mach Law APC (San Diego family law and divorce practice)
Organization: Mach Law APC
Location: 🇺🇸 US
Sector: Legal
Info: https://cti.fyi/#disclosure/N0n/Mach%20Law%20APC%20%28San%20Diego%20family%20law%20and%20divorce%20practice%29Group name: N0n
Post title: Pure Grow Diamonds Inc.
Location: 🇺🇸 US
Sector: Other
Info: https://cti.fyi/#disclosure/N0n/Pure%20Grow%20Diamonds%20Inc.Group name: N0n
Post title: Technoleads Services Inc.
Location: 🇨🇦 CA
Sector: Media & Entertainment
Info: https://cti.fyi/#disclosure/N0n/Technoleads%20Services%20Inc.Group name: N0n
Post title: TOPLIVO AD
Location: 🇧🇬 BG
Sector: Energy & Utilities
Info: https://cti.fyi/#disclosure/N0n/TOPLIVO%20AD#ransomware #cti #threatintelligence #cybersecurity #infosec
-
O detector de mentiras no #Debatenaglobo aponta:
Lula teve 63 falas.
58 falas foram verdadeiras e 5 foram 'não é bem assim'.
Flávio Bolsonaro teve 103 falas.
54 foram mentira, 37 foram 'não é bem assim' e 8 foram verdadeiras.
#LulaNaGlobo
#Somos10MilhoesPorLula
#DebateNaGlobo -
Hoteles en Brasil avanzan lento en el uso de tecnología inteligente
Solo 10% de las empresas de alojamiento y alimentación en Brasil utiliza dispositivos inteligentes o Internet de las Cosas. Seguridad y consumo energético concentran la adopción, mientras la gestión de recursos físicos representa una oportunidad para modernizar la operación hotelera.
Por Deyanira Vázquez | Reportera
Solo una de cada 10 empresas de alojamiento y alimentación en Brasil utiliza dispositivos inteligentes o conectados a Internet, una proporción inferior al promedio nacional de 14% y muy por debajo del 40% registrado entre las empresas de mayor tamaño, de acuerdo con la encuesta TIC Empresas 2025.
El estudio del Centro Regional de Estudios para el Desarrollo de la Sociedad de la Información (Cetic.br) muestra que la tecnología conectada ya tiene presencia en los hoteles y establecimientos de hospedaje, aunque su utilización se concentra principalmente en seguridad y eficiencia energética.
Entre las empresas del sector que utilizan dispositivos inteligentes o Internet de las Cosas (IoT), 96% los emplea para la seguridad de sus instalaciones, mediante alarmas, detectores, cerraduras y cámaras. El manejo del consumo de energía aparece en 59% de los casos.
La tecnología aún se concentra
El uso de tecnología conectada también alcanza otras áreas de la operación, aunque con menor presencia. La gestión de procesos mediante dispositivos inteligentes registra 33%, mientras que la gestión logística llega a 26% y el monitoreo del mantenimiento de equipos alcanza 22%.
Los datos muestran que la digitalización hotelera avanza de manera desigual. Los establecimientos han incorporado primero soluciones destinadas a proteger instalaciones y controlar el consumo energético, mientras la administración conectada de inventarios, equipos y otros recursos físicos todavía tiene un margen importante de crecimiento.
En este escenario, Thiago Bertozo, director de Excelencia Comercial para América Latina y el Caribe de Vingcard, parte de ASSA ABLOY, señaló que el siguiente paso para los hoteles consiste en ampliar la visibilidad sobre los recursos que intervienen diariamente en la operación.
La lógica parte de conectar información que ya generan los sistemas del hotel. Los registros de acceso, por ejemplo, pueden relacionarse con la ocupación de las habitaciones y utilizarse para ajustar el consumo energético, anticipar necesidades de blancos y organizar recursos antes de la llegada de los huéspedes.
Una operación basada en datos
Un hotel puede utilizar los datos de ocupación para determinar qué habitaciones requieren atención prioritaria, cuántos juegos de blancos deben encontrarse disponibles y qué equipos deben estar preparados para atender la demanda de cada jornada.
Esta integración permite que los recursos físicos dejen de administrarse únicamente mediante conteos manuales y pasen a contar con registros digitales sobre su ubicación, utilización y disponibilidad.
La trazabilidad también puede extenderse a elementos que circulan entre almacenes, lavanderías y habitaciones. Con ello, los responsables de la operación pueden conocer qué recurso salió, hacia dónde fue trasladado y cuándo regresó.
El objetivo es construir una operación en la que control de acceso, energía, equipamiento y servicios compartan información para reducir puntos ciegos y mejorar la capacidad de respuesta del establecimiento. –sn–
Sociedad Noticias¡Conéctate con Sociedad Noticias! Suscríbete a nuestro canal de YouTube y activa las notificaciones, o bien, síguenos en las redes sociales: Facebook, Twitter e Instagram.
También, te invitamos a que te sumes a nuestro canal de información en tiempo real a través de Telegram.
#NoticiasMX #PeriodismoParaTi #PeriodismoParaTiSociedadNoticias #ArmaDeFuego #BenitoJuárez #C2Sur #Cdmx #detenciónPolicial #Información #InformaciónMéxico #intentoDeRoboDeMotocicleta #México #Morena #NarvarteOriente #noticia #noticias #NoticiasMéxico #NoticiasSociedad #SecretaríaDeSeguridadCiudadana #seguridadCiudadana #SN #Sociedad #SociedadNoticias #SociedadNoticiasCom #sociedadNoticias #SociedadNoticiasCom #SSC -
Nos artigos anteriores construímos uma visão cada vez mais completa do Apache Spark.
Passamos por:
Data
↓
Partitions
↓
Tasks
↓
Executors
↓
Shuffle
↓
Joins
↓
Spark SQL
↓
Catalyst
↓
Physical PlanMas existe um recurso atravessando praticamente todas essas etapas:
memória.
Quando comecei a estudar problemas de memória no Spark, era tentador resumir tudo a:
OutOfMemory
↓
aumentar RAMHoje eu vejo esse raciocínio como incompleto.
Um problema de memória pode estar relacionado a:
Driver
Executors
Partitions
Shuffle
Broadcast
Cache
Serialization
Garbage Collection
Python workers
Off-heap/native memory
Memory OverheadE aumentar memória sem descobrir qual desses componentes está causando o problema pode apenas tornar um Job caro antes de ele falhar novamente.
A pergunta correta não é:
Quanto de memória devo adicionar?
É:Quem está consumindo memória, por quê, e em qual parte da arquitetura?
1. Memória em uma aplicação Spark
Vamos voltar à arquitetura básica:DRIVER
│
▼
Cluster Manager
│
┌─────────┼─────────┐
▼ ▼ ▼
Executor 1 Executor 2 Executor 3Temos dois contextos que precisam ser diferenciados imediatamente:
Driver Memory
e:
Executor Memory
Essa distinção é fundamental.
Porque:
Driver OOM
e:
Executor OOM
podem ter causas completamente diferentes.
2. Driver Memory
O Driver coordena a aplicação.Ele mantém informações relacionadas a:
- aplicação;
- Jobs;
- Stages;
- Tasks;
- scheduling;
- metadados;
- planos de execução;
- resultados retornados ao Driver;
- estado necessário para coordenar a computação.
Conceitualmente:
DRIVER
│
┌──────────────┼──────────────┐
▼ ▼ ▼
Planning Scheduling Metadata
│ │ │
└──────────────┼──────────────┘
▼
ControlIsso significa que o Driver não deveria ser tratado como destino para todo o dataset distribuído.
Esse ponto parece óbvio.
Até alguém executar:
dados = df.collect()
3. O perigo do
collect()
Considere:df.count()
O processamento acontece de maneira distribuída e o resultado retornado é pequeno:
123456789
Agora compare com:
dados = df.collect()
collect()solicita que todos os registros do DataFrame sejam retornados ao Driver.Conceitualmente:
Executor 1 ──────┐
Executor 2 ──────┤
Executor 3 ──────┼──► DRIVER
Executor 4 ──────┤
Executor 5 ──────┘Se o dataset possuir:
500 GB
e o Driver tiver:
8 GB
temos um problema bastante previsível.
O Spark é distribuído.
Mas acabamos de pedir:
Traga tudo para uma única máquina.
4.
collect()não é ruim — o contexto é que importa
Não existe problema em:df.limit(10).collect()
quando sabemos que o resultado será pequeno.
Também existem cenários legítimos em que precisamos trazer pequenas quantidades de dados ao Driver.
O problema é usar
collect()sem compreender:Distributed Dataset
↓
DriverA pergunta antes de um
collect()deveria ser:Qual o volume máximo que pode voltar para o Driver?
Essa pergunta evita muitos problemas.
5. Outros caminhos para sobrecarregar o Driver
collect()é o exemplo mais conhecido, mas não é o único.Problemas de Driver também podem aparecer com:
- resultados excessivamente grandes;
- estruturas locais gigantes;
- excesso de metadados;
- quantidade extrema de Tasks;
- operações que materializam dados no processo do Driver;
- código Python executado localmente;
- determinadas operações de visualização ou conversão.
Por exemplo:
pdf = df.toPandas()
merece atenção.
O resultado precisa caber na memória do processo que recebe esse DataFrame local.
Ou seja:
Spark DataFrame distribuído
↓
toPandas()
↓
DataFrame local
↓
DRIVERSe os dados forem grandes, temos novamente uma concentração de memória.
6. Executor Memory
Agora vamos para os Executors.Eles executam as Tasks.
Conceitualmente:
Executor
│
├── Task 1
├── Task 2
├── Task 3
└── Task 4Durante a execução, memória pode ser necessária para:
- processamento;
- agregações;
- joins;
- sorting;
- shuffle;
- estruturas intermediárias;
- cache;
- dados serializados;
- execução de código;
- componentes fora do heap JVM.
É aqui que começam vários problemas clássicos.
7. Uma partição vira trabalho para uma Task
Da Parte 3:Em uma determinada Stage, cada partição normalmente corresponde ao trabalho de uma Task.
Então existe uma conexão direta:Partition
↓
Task
↓
Memory pressureImagine:
Partition 1 → 200 MB
Partition 2 → 180 MB
Partition 3 → 220 MB
Partition 4 → 18 GBA Task responsável pela quarta partição terá um perfil completamente diferente das demais.
Podemos observar:
Task 1 → OK
Task 2 → OK
Task 3 → OK
Task 4 → Memory PressureTalvez o problema não seja:
Executor com pouca memória.
Talvez seja:Uma partição absurdamente maior que as outras.
8. Particionamento e memória são inseparáveis
Imagine um dataset de:1 TB
distribuído em:
10 partitions
Simplificando muito:
≈ 100 GB por partition
Agora considere:
1000 partitions
Teríamos algo mais próximo de:
≈ 1 GB por partition
Isso não significa que uma Task precise manter toda a partição simultaneamente em memória.
Mas o exemplo mostra uma relação importante:
O tamanho e a distribuição das partições influenciam diretamente a pressão de memória das Tasks.
É por isso que simplesmente aumentarspark.executor.memorypode esconder a causa real.
9. Execution Memory
Durante operações como:df.groupBy("customer_id").sum("value")
Spark precisa de memória para executar estruturas intermediárias.
Também em:
df.orderBy("timestamp")
ou em determinados joins.
Podemos pensar conceitualmente:
Executor Memory
│
├── Execution
│ │
│ ├── Shuffle
│ ├── Join
│ ├── Sort
│ └── Aggregation
│
└── Storage
│
├── Cached Data
└── Persisted DataNo Spark moderno, execution e storage participam de um modelo de gerenciamento de memória integrado.
Isso é importante porque a memória disponível não deve ser imaginada como caixas totalmente independentes e rígidas em todos os momentos.
10. Storage Memory
Agora imagine:df.cache()
Quando o DataFrame é materializado, Spark pode manter partições para reutilização.
Conceitualmente:
Executor
│
├── Execution Memory
│
└── Storage Memory
│
├── Partition A
├── Partition B
└── Partition CIsso pode ser extremamente útil.
Se o mesmo dataset caro for utilizado várias vezes:
Expensive computation
↓
CACHE
↓
┌─────┼─────┐
▼ ▼ ▼
Use 1 Use 2 Use 3evitamos recalcular repetidamente a mesma linhagem.
Mas cache também custa memória.
11.
cache()não significa "deixe rápido"
Esse é outro anti-pattern comum:df.cache()
ser utilizado como se significasse:
optimize(df)
Não significa.
Imagine um DataFrame de:
800 GB
que será utilizado apenas uma vez.
Fazer cache pode simplesmente:
- consumir memória;
- provocar eviction;
- aumentar pressão sobre o Executor;
- competir com execution memory;
- não trazer benefício relevante.
Cache faz mais sentido quando existe reuso.
Por exemplo:
base = transformacao_cara(df)
base.cache()
resultado_a = base.groupBy("estado").count()
resultado_b = base.groupBy("produto").sum("valor")
resultado_c = base.filter("status = 'ACTIVE'")Agora existe um motivo claro:
Expensive Base
↓
CACHE
↓
┌────┼────┐
▼ ▼ ▼
A B C12. Cache também é Lazy
Considere:df.cache()
Isso não significa necessariamente:
Neste instante, todas as partições foram computadas e armazenadas.
A materialização ocorre quando uma Action força a computação.Por exemplo:
df.cache()
df.count()
Agora temos:
cache()
↓
mark for persistence
↓
count()
↓
compute partitions
↓
store according to persistence strategyLazy evaluation continua presente.
13.
persist()
Além de:df.cache()
podemos trabalhar com:
df.persist()
e escolher estratégias de persistência adequadas ao contexto.
Conceitualmente, a persistência pode envolver combinações de:
Memory
Disk
Serialization
ReplicationA escolha depende de fatores como:
- tamanho;
- frequência de reuso;
- custo de recomputação;
- memória disponível;
- tolerância a I/O.
Novamente, não existe uma configuração universalmente melhor.
14. E quando a memória não é suficiente?
Agora chegamos a algo que apareceu na Parte 4:Spill
Imagine uma Task realizando:Sort
ou:
Aggregation
ou processamento relacionado a:
Shuffle
Ela utiliza estruturas em memória.
Mas a quantidade necessária ultrapassa o que pode ser mantido eficientemente ali.
Então parte dos dados pode ser enviada para disco.
Conceitualmente:
Task
↓
Memory
↓
Memory pressure
↓
Spill
↓
DiskDepois:
Disk
↓
Read
↓
Continue processingIsso permite que determinadas operações continuem mesmo quando tudo não cabe simultaneamente em memória.
Mas existe um preço.
15. Spill troca memória por I/O
Compare:Memory
↓
CPUcom:
Memory
↓
Disk Write
↓
Disk Read
↓
CPUDisco normalmente é muito mais lento do que memória.
Então grandes volumes de spill podem transformar:
Job
em:
Job lento
Mesmo sem ocorrer um OutOfMemory.
Essa é uma lição importante:
Uma aplicação pode estar sofrendo de pressão de memória sem necessariamente falhar por OOM.
Ela pode simplesmente ficar muito mais lenta.
16. Shuffle + Memory + Spill
Agora conectamos vários artigos.Considere:
resultado = (
vendas
.groupBy("customer_id")
.sum("valor")
)Podemos ter:
Partitions
↓
Partial Aggregation
↓
Shuffle Write
↓
Network
↓
Shuffle Read
↓
Aggregation
↓
Memory pressure
↓
Spill
↓
DiskAgora um simples:
groupBy()
ganha uma interpretação completamente diferente.
17. Data Skew volta novamente
Imagine:P1 = 200 MB
P2 = 210 MB
P3 = 190 MB
P4 = 15 GBDurante uma agregação:
P1 → OK
P2 → OK
P3 → OK
P4 → Spill → Spill → SpillOu pior:
P4 → OutOfMemory
A reação inicial pode ser:
Aumentar executor memory.
Talvez funcione.Mas talvez a pergunta correta seja:
Por que existe uma partição de 15 GB quando as demais possuem aproximadamente 200 MB?
Estamos novamente diante de:Data Skew
A causa é distribuição.
O sintoma aparece na memória.
18. OutOfMemory não é um único problema
Quando alguém diz:"Spark deu OOM."
Ainda sabemos muito pouco.Precisamos perguntar:
Onde?
Por exemplo:
Driver OOM?
ou:
Executor OOM?
ou pressão fora do heap/container?
Também precisamos perguntar:
Em qual Stage?
Em qual operação?
Em todas as Tasks?
Em uma única Task?
Depois de um Shuffle?
Durante Broadcast?
Durante collect()?
Essas perguntas mudam completamente a investigação.
19. Um Driver OOM pode indicar problema de arquitetura
Imagine:dados = df.collect()
sobre um dataset enorme.
Podemos aumentar:
spark.driver.memory
de:
4 GB
para:
16 GB
Depois:
32 GB
Depois:
64 GB
Talvez o Job finalmente funcione.
Mas a pergunta continua:
Por que estamos trazendo um dataset distribuído gigantesco para um único processo?
Aumentar memória resolveu o sintoma.Talvez não tenha resolvido o design.
20. Executor OOM também pode esconder outro problema
Agora imagine:Executor OOM
A reação:
spark.executor.memory
8 GB → 16 GBMas talvez exista:
uma partition = 40 GB
Ou:
join skewed
Ou:
broadcast excessivo
Ou várias Tasks concorrentes disputando recursos.
Ou consumo significativo fora do heap principal.
Então:
Executor OOM não significa automaticamente que o Executor precisa apenas de mais heap.
21.
spark.executor.memory
Uma configuração conhecida é:spark.executor.memory
Ela define a quantidade de memória heap disponibilizada ao processo Executor JVM.
Por exemplo:
--executor-memory 8g
Mas existe uma armadilha conceitual importante:
A memória total necessária por um Executor não é necessariamente igual ao valor de
spark.executor.memory.
Existe memória utilizada fora desse heap.E isso nos leva diretamente ao tema do material original que estudei:
Memory Overhead
22. O que é Memory Overhead?
Uma aplicação Spark não utiliza memória apenas para o heap principal da JVM.Podemos pensar de forma simplificada:
Executor Container / Process Environment
│
├── JVM Heap
│
│ └── spark.executor.memory
│
└── Additional / Non-Heap Memory
│
├── JVM overhead
├── native memory
├── Python processes
├── direct buffers
└── other runtime overheadÉ essa segunda região que torna
memoryOverheadtão importante.Dependendo do ambiente e do workload, um Executor pode morrer mesmo quando aparentemente existe heap suficiente.
23. Um exemplo conceitual
Imagine uma configuração:Executor Heap
8 GBIsso não significa necessariamente:
Executor total
=
8 GBO processo também precisa de espaço para outras necessidades.
Podemos pensar:
Container / Pod / Executor allocation
┌───────────────────────────────┐
│ │
│ JVM Heap │
│ spark.executor.memory │
│ │
├───────────────────────────────┤
│ │
│ Memory Overhead │
│ │
│ Native / Python / Direct / │
│ JVM non-heap / other │
│ │
└───────────────────────────────┘Se a região adicional for insuficiente, o processo pode exceder os limites impostos pelo gerenciador de recursos.
24. Por que isso aparece muito com PySpark?
Em PySpark existe uma característica importante.Nosso código Python não transforma a JVM inteira em Python.
Existe interação entre:
JVM
↕
Python workerConceitualmente:
Executor JVM
│
├── Spark execution
│
└── Python worker
│
└── Python codeEsses processos também consomem memória.
Dependendo do workload, bibliotecas e operações utilizadas, isso pode se tornar relevante para o consumo total do Executor.
Portanto, em PySpark precisamos olhar além de:
JVM Heap
25. Memory Overhead no material histórico
Uma das anotações que motivou este capítulo tratava especificamente de problemas dememoryOverhead.Esse tipo de problema continua conceitualmente relevante.
O que mudou ao longo dos anos foram:
- versões do Spark;
- nomes e comportamento de determinadas configurações;
- resource managers;
- defaults;
- cálculo automático de overhead;
- integração com containers;
- Kubernetes;
- execução Python;
- mecanismos internos de memória.
Por isso não considero uma boa prática pegar uma configuração antiga e simplesmente reproduzi-la hoje.
O conceito continua válido.
A configuração precisa ser analisada no contexto da versão e do ambiente atuais.
26. Heap vs. Off-Heap vs. Overhead
Uma simplificação útil é:PROCESS MEMORY
│
├── JVM Heap
│
├── JVM Non-Heap
│
├── Direct / Native Memory
│
├── Python Worker Memory
│
└── Runtime OverheadIsso é mais próximo da realidade do que pensar:
memory = spark.executor.memory
Quando um container é encerrado por ultrapassar limite de memória, precisamos descobrir qual parte do consumo cresceu.
27. Garbage Collection
Agora vamos entrar em outro sintoma importante:GC
A JVM gerencia automaticamente memória de objetos.Objetos são criados:
Objects
↓
HeapDepois deixam de ser necessários.
O Garbage Collector precisa recuperar esse espaço.
Em um cenário saudável:
Application Work ███████████████████
GC █
Mas sob forte pressão podemos encontrar algo mais próximo de:
Application ███████
GC █████████████
Ou seja:
A aplicação passa tempo demais tentando gerenciar memória em vez de processar dados.
28. GC alto é sintoma
Assim como OOM, GC excessivo não deveria gerar automaticamente:Aumente a heap.
Talvez tenhamos:- objetos demais;
- partições grandes;
- agregações pesadas;
- estruturas intermediárias enormes;
- cache excessivo;
- serialização inadequada;
- concorrência excessiva por Executor.
Precisamos descobrir por que a memória está sob pressão.
29. Mais cores por Executor também afetam memória
Imagine:Executor
8 coresDependendo da configuração, várias Tasks podem executar simultaneamente nesse Executor.
Conceitualmente:
Executor Memory
│
┌────┼────┬────┬────┬────┐
▼ ▼ ▼ ▼ ▼ ▼
T1 T2 T3 T4 T5 ...Cada Task pode precisar de memória.
Então existe uma relação:
mais Tasks concorrentes por Executor
↓
mais competição pela memória disponívelIsso mostra por que tuning não deveria analisar:
executor memory
isoladamente.
Precisamos olhar para:
Executor Memory
+
Executor Cores
+
Partition Size
+
Task Behavior30. Executors gigantes também não são automaticamente melhores
Poderíamos pensar:1 Executor
64 cores
256 GB RAMParece poderoso.
Mas Executors gigantes podem trazer trade-offs relacionados a:
- concorrência;
- garbage collection;
- blast radius de falha;
- utilização;
- scheduling;
- memória compartilhada entre muitas Tasks.
No outro extremo:
64 Executors
1 core
4 GBtambém possui trade-offs.
Não existe um tamanho universal.
Precisamos equilibrar:
cores
memory
parallelism
partition size
workload
cluster manager31. Broadcast também consome memória
Na Parte 5 vimos:from pyspark.sql.functions import broadcast
resultado = grande.join(
broadcast(pequena),
"id"
)A estratégia pode evitar um shuffle grande.
Mas existe um custo:
Small Table
↓
Broadcast
┌──┼──┐
▼ ▼ ▼
E1 E2 E3Cada Executor precisa conseguir trabalhar com a estrutura transmitida.
Se tentarmos broadcast de algo grande demais, podemos criar pressão significativa de memória.
Novamente:
Network optimization
↕
Memory costSistemas distribuídos são cheios de trade-offs.
32. Cache também compete por recursos
Imagine:df_a.cache()
df_b.cache()
df_c.cache()
df_d.cache()Pode parecer:
Quanto mais cache, melhor.
Mas:Cache A
Cache B
Cache C
Cache D
↓
Storage Pressure
↓
Eviction / recomputation / resource competitionCache deveria ser uma decisão baseada em:
reuse frequency
×
recomputation cost
×
available resourcese não um reflexo automático.
33.
unpersist()
Se um dataset não será mais reutilizado, podemos liberar sua persistência:df.unpersist()
Isso comunica:
Não preciso mais manter essas partições persistidas.
Em pipelines longos isso pode ser importante.Por exemplo:
Phase A
↓
cache intermediate
↓
reuse several times
↓
phase completed
↓
unpersist
↓
free resources for Phase BGerenciamento de memória também faz parte do design do pipeline.
34. O Spark UI volta a ser essencial
Se existe problema de memória, não quero começar alterando configurações.Quero observar.
No Spark UI e métricas relacionadas, procuro sinais como:
Task Duration
GC Time
Shuffle Read
Shuffle Write
Spill
Storage
Executor behavior
Failed Tasks
SkewTambém observo logs.
A pergunta é:
O que aconteceu antes da falha?
35. Um padrão de investigação
Imagine:Job falhou
↓
Executor lost
↓
Memory-related errorMeu raciocínio começaria assim:
Qual Stage?
↓
Qual operação?
↓
Join?
Aggregation?
Sort?
UDF?
Cache?Depois:
Todas as Tasks falharam?
↓
ou apenas algumas?Se apenas algumas:
Possível skew?
Depois:
Qual tamanho das partitions?
Quanto shuffle?
Quanto spill?
Quanto GC?Só então:
Heap insuficiente?
Overhead insuficiente?
Particionamento ruim?
Broadcast inadequado?
Concorrência excessiva?36. Caso 1 — Driver morrendo
Sintoma:Driver OutOfMemory
Código:
dados = df.collect()
Dataset:
120 GB
Driver:
8 GB
Diagnóstico provável:
Distributed Data
↓
collect()
↓
Single Process
↓
OOMSolução arquitetural:
Não coletar o dataset inteiro.
Talvez:df.write.parquet(
"/data/output"
)ou continuar o processamento distribuído.
A solução principal não é necessariamente:
8 GB → 128 GB
37. Caso 2 — Uma Task morre repetidamente
Sintoma:Stage 12
199 Tasks → OK
1 Task → FAILIsso é extremamente informativo.
Talvez tenhamos:
Data Skew
ou uma partição muito maior.
Se aumentarmos memória de todos os Executors:
Cluster cost ↑
para resolver uma única partição anormal, talvez estejamos atacando o lugar errado.
Precisamos investigar a distribuição.
38. Caso 3 — Todas as Tasks sofrem Spill
Imagine:Task 1 → heavy spill
Task 2 → heavy spill
Task 3 → heavy spill
Task 4 → heavy spill
...Agora talvez tenhamos um problema sistêmico.
Possíveis causas:
Partitions muito grandes
Memory insuficiente
Join pesado
Sort pesado
Aggregation pesada
Task concurrencyNesse cenário, ajustar recursos pode realmente fazer parte da solução.
Mas ainda precisamos medir.
39. Caso 4 — OOM depois de Broadcast
Imagine que:Job funcionava
e alguém adicionou:
broadcast(dim)
Agora Executors começam a morrer.
Pergunta:
Qual o tamanho real de dim?
Talvez:
"small table"
tenha crescido.
Ontem:
50 MB
Hoje:
6 GB
Uma otimização válida no passado pode se tornar um problema quando os dados mudam.
Isso é importante:
Performance depende também da evolução dos dados.
40. Caso 5 — PySpark e memória externa ao heap
Imagine:spark.executor.memory
aparentemente confortável.
Mas containers continuam sendo encerrados por memória.
Agora precisamos olhar para:
JVM Heap
+
Python workers
+
Native memory
+
Direct buffers
+
Other overheadÉ exatamente nesse tipo de cenário que compreender
memoryOverheaddeixa de ser detalhe e passa a ser parte do diagnóstico.
41. Não ajuste
memoryOverheadàs cegas
Se um Executor morre por ultrapassar limites externos ao heap, aumentar overhead pode ser apropriado.Mas ainda precisamos perguntar:
Por que esse consumo existe?
Pode ser:
- Python;
- bibliotecas nativas;
- buffers;
- comportamento da JVM;
- volume de dados;
- operação específica.
A configuração correta depende do workload e do ambiente.
Por isso evito recomendações como:
sempre configure X GB
ou:
sempre use Y%
sem contexto.
Defaults e comportamentos também evoluem entre versões.
42. Memória em Kubernetes
Em ambientes containerizados, a questão fica ainda mais visível.Podemos pensar:
Kubernetes Pod
│
└── Executor
│
├── JVM Heap
├── Non-Heap
├── Native
├── Python
└── OverheadO Pod possui limites.
Não basta a JVM achar que possui heap suficiente.
O consumo total do processo e componentes associados precisa respeitar os recursos disponíveis.
Esse é um dos motivos pelos quais problemas modernos de Spark precisam ser analisados também no nível da infraestrutura.
43. Memória em YARN
Em ambientes YARN, existe raciocínio semelhante.O Executor executa dentro de recursos controlados pelo gerenciador do cluster.
Historicamente, muitos erros de
memoryOverheadficaram conhecidos justamente em ambientes onde o container ultrapassava seu limite mesmo quando a heap configurada parecia aceitável.O princípio permanece:
JVM Heap
≠
Total Process Memory44. A configuração depende do ambiente
Hoje Spark pode rodar em diferentes contextos:Standalone
YARN
Kubernetes
Managed Platforms
Cloud ServicesIsso significa que recomendações de memória precisam considerar:
- Spark version;
- cluster manager;
- container limits;
- JVM;
- Python;
- workload;
- plataforma gerenciada.
Uma configuração copiada de um artigo antigo pode estar:
correta historicamente
e:
inadequada atualmente
ao mesmo tempo.
Esse é exatamente o tipo de cuidado que estou aplicando ao revisitar meu material antigo nesta série.
45. Um modelo mental melhor para OOM
Em vez de:OOM
↓
More Memoryprefiro:
OOM
│
┌──────────┴──────────┐
▼ ▼
Driver? Executor?
│ │
▼ ▼
collect()? Which Stage?
toPandas()? │
metadata? ▼
Which Operation?
│
┌──────────┼──────────┐
▼ ▼ ▼
Skew Shuffle Broadcast
│ │ │
└──────────┼──────────┘
▼
Partition Size
│
▼
Heap or Overhead?
│
▼
Root CauseEsse modelo evita tratar todos os erros de memória como iguais.
46. Performance tuning começa com observabilidade
Imagine dois engenheiros.O primeiro vê:
OutOfMemoryError
e imediatamente altera:
spark.executor.memory
O segundo investiga:
Stage
Tasks
Partition distribution
Shuffle
Spill
GC
Executor logs
Physical plan
Data volumeO segundo talvez leve alguns minutos a mais antes de alterar a configuração.
Mas a chance de resolver a causa real é muito maior.
Essa é uma diferença importante entre:
configuration tuning
e:
performance engineering
47. Um checklist para problemas de memória
Quando encontro um problema de memória em Spark, quero responder:- O erro aconteceu no Driver ou Executor?
- Qual Stage estava executando?
- Qual operação estava acontecendo?
- Existe
collect()? - Existe
toPandas()? - Existe broadcast?
- Existe cache excessivo?
- As partições estão equilibradas?
- Existe data skew?
- Qual o tamanho das maiores Tasks?
- Existe Shuffle?
- Quanto?
- Existe Spill?
- Quanto?
- Quanto tempo está sendo gasto em GC?
- Todas as Tasks sofrem ou apenas algumas?
- Existem Python workers?
- Existe consumo nativo relevante?
- O limite do container está sendo ultrapassado?
- O problema é heap ou overhead?
- A configuração corresponde à versão e ao cluster manager utilizados?
Só depois:
Qual configuração preciso alterar?
48. O que eu evitaria fazer automaticamente
Se o Job estiver lento ou falhando, eu evitaria começar por:dobrar executor memory
ou:
dobrar driver memory
ou:
aumentar memoryOverhead arbitrariamente
ou:
cachear tudo
ou:
reduzir o número de partitions sem medir
ou:
aumentar o cluster
Todas essas ações podem ser válidas.
Mas nenhuma delas deveria substituir diagnóstico.
49. Memória, performance e custo
Em cloud, existe ainda outra dimensão.Imagine:
Executor Memory
8 GBe simplesmente dobramos para:
16 GB
em dezenas ou centenas de Executors.
Talvez o Job fique estável.
Mas talvez tenhamos acabado de aumentar recursos para compensar:
Data Skew
ou:
repartition ruim
ou:
join inadequado
ou:
cache desnecessário
Então temos:
Problema arquitetural
↓
Mais infraestrutura
↓
Maior custo
↓
Problema mascaradoPerformance tuning também é FinOps.
50. A conexão entre tudo que vimos até aqui
Agora podemos montar uma visão muito mais completa:DATA
│
▼
PARTITIONS
│
▼
TASKS
│
▼
EXECUTORS
│
┌───────────┼───────────┐
▼ ▼ ▼
Memory CPU Network
│ │
▼ ▼
Aggregation Shuffle
│ │
└───────────┬───────────┘
▼
Spill
│
▼
Disk
│
▼
Performance
│
▼
CostAgora adicione:
Data Skew
e podemos gerar:
Uneven Partition
↓
Huge Task
↓
Memory Pressure
↓
Spill / GC
↓
Slow Task
↓
Straggler
↓
Slow StageIsso mostra por que os capítulos anteriores estavam conectados.
51. A principal lição deste capítulo
Se eu pudesse resumir memória no Spark em uma frase:Problemas de memória frequentemente são sintomas de como os dados e a computação foram distribuídos.
Nem sempre.Às vezes realmente precisamos de mais memória.
Mas antes de aumentar recursos, quero saber:
Quem está consumindo?
↓
Onde?
↓
Durante qual operação?
↓
Por quê?Só então:
Architecture
+
Configuration
+
Resourcesentram na solução.
52. Como penso hoje
Meu modelo mental deixou de ser:Spark OOM
↓
Increase Memorye passou a ser:
Spark OOM
↓
Driver or Executor?
↓
Heap or Overhead?
↓
Which Stage?
↓
Which Task?
↓
Which Operation?
↓
Partition Size?
↓
Skew?
↓
Shuffle?
↓
Spill?
↓
Broadcast?
↓
Cache?
↓
Python / Native Memory?
↓
Root Cause
↓
Then TuneEsse raciocínio é muito mais útil do que decorar valores de configuração.
Próximo artigo
Agora entendemos:Partitions
↓
Tasks
↓
Memory
↓
Shuffle
↓
SpillMas existe outro conceito fundamental que apareceu desde os primeiros artigos:
Lineage.
Quando uma partição é perdida, como Spark sabe reconstruí-la?
Por que RDD significa:
Resilient Distributed Dataset
?
Como Spark obtém tolerância a falhas sem simplesmente replicar toda computação intermediária?
E o que acontece quando a linhagem fica grande demais?
No próximo artigo vamos explorar:
- RDD Lineage;
- DAG;
- fault tolerance;
- recomputation;
- cache vs. recomputation;
- checkpoint;
- persistência;
- falha de Executor;
- recuperação de partições;
- por que Spark é "resilient";
- e como essas ideias evoluíram nas APIs modernas.
Vamos partir deste modelo:
Source
↓
Map
↓
Filter
↓
Join
↓
Aggregate
↓
Resultpara enxergar algo mais profundo:
LINEAGE
│
▼
Source → Transform → Transform → Shuffle → Result
│ │ │
└──────────┴──────────┘
│
information needed
for recomputationEssa é uma das ideias fundamentais que fizeram o Spark ser Spark.
← Parte 6: Spark SQL e DataFrames — do código ao plano de execução
Próximo: Parte 8 — RDD Lineage e tolerância a falhas: como o Spark se recupera quando algo dá errado#cluster #spark #python #bigdata #software #coding #development #engineering #inclusive #community
Como aprendi Apache Spark — Parte 7: Memória — Executors, Driver, Cache, Spill e OutOfMemory -
This year, maxxing stood out because it really connects to so many different parts of life. People are proteinmaxxing their breakfast, tokenmaxxing their use of AI during the workday, cozymaxxing on a Friday night.”
https://www.theguardian.com/science/2026/oct/26/maxxing-word-of-the-year-dictionary
-
AI means we code writers no longer write any code, but I say we're getting more talkative and social and friendly, so that’s good
-
Another day another app that helps you uninstall apps from your Mac — I have yet to find the perfect one, but this looks promising
-
The problem isn’t just that AI has made it easier to hack. It’s that Wall Street forces the use of software that is easy to hack because poorly written software is more profitable to sell.
https://www.thebignewsletter.com/p/monopoly-round-up-the-real-reason