Multiprocessing

Write parallel processing with multiprocessing.Pool.

The parallel processing layer

In this lesson you will add parallel square computation with multiprocessing.Pool. You define a square function and apply it to all items in a list with Pool.map.

Pool.map preserves input order, so the output is deterministic. The previous lessons' Tool, Field and ModelMeta code is already in the starting code. You only add the square function and the Pool.map call. This layer will be combined with ctypes in the next lesson.

Exercise Compute squares in parallel with Pool

The starting code already has Tool, Field and ModelMeta. Now import with from multiprocessing import Pool. Write a square(x) function returning x * x. Inside a with Pool() as p: block assign p.map(square, [1, 2, 3]) to result. Print result.

Show example solution

# Build the Tool class with type()
Tool = type("Tool", (), {
    "name": "arac",
    "run": lambda self: f"{self.name} calisti",
})

# Add Field descriptor and ModelMeta
class Field:
    def __set_name__(self, owner, name):
        self.name = name
        if not hasattr(owner, "fields"):
            owner.fields = []
        owner.fields.append(name)

class ModelMeta(type):
    def __new__(mcs, name, bases, ns):
        return super().__new__(mcs, name, bases, ns)

class Model(metaclass=ModelMeta):
    ad = Field()

# Add parallel square computation
from multiprocessing import Pool

def square(x):
    return x * x

with Pool() as p:
    result = p.map(square, [1, 2, 3])
print(result)

Next step: ctypes

Parallel square computation is ready. In the next lesson you will add a native code layer: calling abs with ctypes.CDLL.

This layer will add the ability to call functions from a C library. So far the Tool, Field, ModelMeta and Pool layers are ready. The final lesson will combine everything.

Test yourself

Complete the Pool call

with ____() as p:
    result = p.map(square, [1, 2, 3])

Show answer

with Pool() as p:
    result = p.map(square, [1, 2, 3])

Match multiprocessing concepts

Pool

Process pool
square

Square function
map

Applies in parallel
result

Result list
What does Pool.map provide?
- Randomly ordered result
- Parallel result preserving input order
- A single value
- An error
Show answer

Parallel result preserving input order — Pool.map runs in parallel but preserves input order; the output is deterministic.

Next lesson: ctypes

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies