Max out CPU with parallel API calls to local endpoint using Python

Question

Python 3.10

I've been tasked with proving I can max out the CPU of my Mac laptop (10 cores) by calling a local API endpoint which runs in a Java VM, as well as "measure and record throughput," all using Python. For parallelization, I have researched and decided to go with asyncio per this answer: https://stackoverflow.com/a/59385935/7191927

I plan to use htop to show all cores maxed out so that part I think I have covered. Where I'm getting tripped up is what I actually need to do in the code to max out the CPU.

This is what I have so far. This code is to call two local API endpoints (which each just process blocks of text and extract relevant terms):

import asyncio
from api import API, DocumentParameters, EndException


def background(f):
    def wrapped(*args, **kwargs):
        return asyncio.get_event_loop().run_in_executor(None, f, *args, **kwargs)
    return wrapped

@background
def get_word_results(data):
    api = API(url='http://localhost:8181/rest/words')     
    words_data = data        
    params = DocumentParameters()
    params["content"] = words_data 
    try:
        result = api.words(params)
    except EndException as exception:
        print(exception)
    return result

@background
def get_language_results(data):
    api = API(url='http://localhost:8181/rest/languages')     
    language_data = data        
    params = DocumentParameters()
    params["content"] = language_text_data 
    try:
        result = api.language(params)
    except EndException as exception:
        print(exception)
    return result

if __name__ == '__main__':
    filepath = "/Users/me/stuff.txt"
    with open(filepath, 'r') as file: 
        data = file.read()
    get_word_results(data)
    get_language_results(data)
    print('Done.')

This is where my Python knowledge/experience begins to wane.

So what would be the most efficient way to:

1. Run this code continuously and at increasing thread counts in attempt to max out the CPU.
2. Measure and record throughput, as per the requirement.

EDIT 1 - Bounty started. I need a solid solution for this - which maxes out CPU and gives some kind of output that shows this, as well as how many calls are being made and causing the max. Based on what Mr Miyagi says in the comments, it sound like multiprocessing is what I want, either instead of or in tandem with asyncio The winner will achieve with the lowest amount of lines of code.

EDIT 2 - it must be accomplished using using one script/program, being run once, rather than running the same script multiple times.

Answer 1

Using asyncio is a good choice. I would pair that with aiohttp to make the calls to the java service. Here is a skeleton script with an awaitable test() method that will allow you to run as many calls as you want, with as many of those calls running in parallel as you want:

import asyncio
import aiohttp

async def test():
  # examples: will run a total of 'task_count' calls limited to 'concurrency' running in parallel 
  task_count = 1000
  concurrency = 10

  async with aiohttp.ClientSession('http://localhost:8181') as session:
    semaphore = asyncio.Semaphore(concurrency)
    tasks = [asyncio.ensure_future(call_service(session, semaphore, task_id)) for task_id in range(0, task_count)]
    await asyncio.gather(*tasks)

async def call_service(session, semaphore, task_id):
  async with semaphore:

    # start your timer here

    async with session.get('/rest/words') as resp:
      await resp.text()
      # stop your timer here and log/accumulate stats

The principal here is that a list of async tasks are created that can potentially execute all at the same time. However, you want to know how many it takes to max out your CPU so a concurrency parameter is provided that allows you to throttle how many calls happen at the same time by using a semaphore.

I've commented where you can add your statements to start measuring the timings.

Answer 2

For a quick way just run the same python file multiple times. To max just run 20 python scripts at once or something.