Mojo Academy · Aula

Dividindo o trabalho em blocos

Divida um intervalo para equilibrar a carga.

Dividindo o trabalho em blocos é uma aula grátis de Mojo Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Mojo Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Mojo Academy inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why Chunk at All

Launching a thread per element is wasteful. Instead you split the range into a few larger chunks, one per worker.

A Chunk Is a Slice

Each chunk is just a contiguous slice of indices, like 0 to 99 or 100 to 199. One worker owns one slice.

Pick a Chunk Count

A common choice is one chunk per core. You ask the machine for that number with num_physical_cores.

var workers = num_physical_cores()

Compute the Chunk Size

Divide the total length by the worker count to get how many items each worker should handle.

var chunk = (n + workers - 1) // workers

Find a Chunk's Start

Inside the work function, the chunk index tells you where to begin. Multiply it by the chunk size.

var start = c * chunk

Clamp the End

The last chunk may run past the data, so clamp its end to the total length with min to stay in bounds.

var end = min(start + chunk, n)

Loop Inside the Chunk

Each worker runs a normal loop over just its own range. Inside the chunk it is plain, ordinary code.

for i in range(start, end):
    out[i] = heavy(i)

parallelize Over Chunks

Now you call parallelize with the number of chunks, not the number of elements. Each call processes one whole chunk.

parallelize[do_chunk](workers)

Balance the Load

Equal-sized chunks keep every core equally busy. If one chunk is far bigger, that worker finishes late.

More Chunks Than Cores

When some items cost more than others, using more, smaller chunks lets fast workers grab extra work and stay busy.

Tune by Measuring

The best chunk count depends on your data and machine. Try a few sizes and keep the one your benchmark likes.

Quick Check

You split a length-n array into one chunk per worker.

Recap

You divide the range into balanced chunks, clamp each end with min, loop inside a chunk, and call parallelize over the chunk count for even load. 🚀

Perguntas Frequentes

A aula “Dividindo o trabalho em blocos” é grátis?

Sim — o texto completo de “Dividindo o trabalho em blocos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Mojo Academy, atualize para CoddyKit PRO. O curso de Mojo Academy inclui 4 aulas no total.

O que vou aprender em “Dividindo o trabalho em blocos”?

Divida um intervalo para equilibrar a carga. Você pratica Mojo Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Mojo Academy?

Nenhuma experiência prévia é necessária. Mojo Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Dividindo o trabalho em blocos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Mojo Academy?

Sim. Cada aula de Mojo Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Mojo Academy