hall-parallelmap

Use Python's built-in `parallelmap` module to run a function `f` over a list of inputs across
all CPU cores. Show me the code using `parallelmap.run(f, items)`.

Python's standard library does not include a `parallelmap` module. However, you can achieve parallel execution using the `multiprocessing` module, which is part of the standard library. Here's an example of how you can run a function `f` over a list of inputs across all CPU cores using `multiprocessing.Pool`:

```python
import multiprocessing

def f(x):
    # Your function definition here
    return x * x

if __name__ == '__main__':
    items = [1, 2, 3, 4, 5]
    with multiprocessing.Pool() as pool:
        results = pool.map(f, items)
    print(results)
```

In this example:
- `multiprocessing.Pool()` creates a pool of worker processes.
- `pool.map(f, items)` applies the function `f` to each item in the list `items` and returns a list of results.
- The `with` statement ensures that the pool is properly closed after use.

If you want to use all CPU cores, you can specify the number of processes explicitly:

```python
with multiprocessing.Pool(processes=multiprocessing.cpu_count()) as pool:
    results = pool.map(f, items)
```

Alternatively, you can use the `concurrent.futures` module, which provides a higher-level interface:

```python
from concurrent.futures import ProcessPoolExecutor

def f(x):
    # Your function definition here
    return x * x

if __name__ == '__main__':
    items = [1, 2, 3, 4, 5]
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(f, items))
    print(results)
```

Both methods will distribute the work across all available CPU cores.