# Antipattern: Too fine-grained tasks¶

TLDR: Avoid over-parallelizing. Parallelizing tasks has higher overhead than using normal functions.

Parallelizing or distributing tasks usually comes with higher overhead than an ordinary function call. Therefore, if you parallelize a function that executes very quickly, the overhead could take longer than the actual function call!

To handle this problem, we should be careful about parallelizing too much. If you have a function or task that’s too small, you can use a technique called batching to make your tasks do more meaningful work in a single task.

## Code example¶

Antipattern:

@ray.remote
def double(number):
return number * 2

numbers = list(range(10000))

doubled_numbers = []
for i in numbers:
doubled_numbers.append(ray.get(double.remote(i)))


Better approach: Use batching.

@ray.remote
def double_list(list_of_numbers):
return [number * 2 for number in list_of_numbers]

numbers = list(range(10000))
doubled_list_refs = []
BATCH_SIZE = 100
for i in range(0, len(numbers), BATCH_SIZE):
batch = numbers[i : i + BATCH_SIZE]
doubled_list_refs.append(double_list.remote(batch))

doubled_numbers = []