Asyncio performance with synchronous code

Question

I create the following test to check performance with running synchronous code in async function.

In return_random function can be something like write log, dump or load json, validate in-out date, which call other functions... etc.

count_sync and count_async variables using for skip overhead for open and close event loop. just calculate time inside function.

This part of code just call synchronous function count times.

import timeit
from time import time
from random import random

count = 100
run_numbers = 100000

count_sync = 0

def return_random():
    return random()

def test():
    global count_sync
    start = time()
    for _ in range(count):
       return_random()
    count_sync += time() - start
    return

total_sunc = timeit.timeit('test()', globals=globals(), 
      number=run_numbers))

Same code but now return_random is asynchronous function:

import asyncio
import uvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

count_async = 0

async def return_random_async():
   return random()

async def test_async():
   global count_async
   start = time()
   for _ in range(count):
      await return_random_async()
   count_async += time() - start
   return

total_sunc = timeit.timeit('asyncio.run(test_async())', globals=globals(), number=run_numbers)

After running code with different numbers of call function and count of timeit running got following results:

RUNNING run_numbers: 1000. CALL FUNCTIONS count: 1000
total sync:  0.12023316
total Async: 0.48369559500000003
inside def sync  0.11995530128479004
inside def Async:0.24073457717895508

RUNNING run_numbers: 100000. CALL FUNCTIONS count: 100
total sync:   1.422697458
total Async: 25.452165134999998   (!!!)
inside def sync:  1.3965537548065186
inside def Async: 2.8397130966186523

All times run with synchronous function faster more than 2 times.

Is it means that running synchronous code better with not async function? And preferably do not use a lot async functions ?

Answer 1

You need to use async functions only when you really need. Examples: asynchronous http libraries like aiohttp, asynchronous drivers like motor_asyncio for MongoDB, etc. In other cases it's better to run synchronous code with not async functions, because they have an overhead that you don't need to have.