nominatim-api performance VS nominatim over HTTP performance

[MRigal]

Hi all,

Thanks for the good work for providing Nominatim!

Based on the docs and on some content of #3404 I was looking for a way to get (especially reverse) geocoding faster for our use-case.

I thought that the direct DB search via nominatim-api would be quite faster than the geocoding via HTTP. And doing first tests (not optimized for parallel searches, so not expecting to be really faster), I'm surprised how slower they actually are!!!

I've also tested https://github.com/traccar/traccar-geocoder as they claim to be much faster.

I have a test file on a branch on the open source project I'm working on if you wanna check it: https://gitlab.com/prospect-energy/prospect-server/-/merge_requests/2656/diffs?commit_id=83317d276fe319079902532ce566fcfb530f93d6

The access via API appears to be more than 4x slower, on 3 servers with the same middle-size hardware. Is it really expected to behave that slow on classical parallel requests?

Here is the content simplified, HTTP requests are based on geopy to have it as close as possible to our usage:

# ruff: noqa: T201, ANN001
"""Location perf testing module."""

import timeit
from functools import cache, partial

import nominatim_api as napi
from geopy.adapters import RequestsAdapter
from geopy.geocoders.base import DEFAULT_SENTINEL
from geopy.geocoders.nominatim import _DEFAULT_NOMINATIM_DOMAIN, Nominatim, Traccar
from geopy.util import logger


lat = 1.6
lon = 32.8


@cache
def get_nominatim_geocoder() -> Nominatim:
    """Create Nominatim client for the location service."""
    connection_string = ""
    return Nominatim(
        user_agent="dataworker",
        domain=connection_string,
        adapter_factory=RequestsAdapter,
        timeout=3,
        scheme="http",
    )


def geopy_http_test(geocoder: Nominatim | Traccar, runs: int = 1) -> None:
    """Testing nominatim over HTTP."""
    global lat, lon
    kwargs = {"language": "en,fr"}
    # nominatim = get_nominatim_geocoder()
    for _ in range(runs):
        lat += 0.001
        lon += 0.001
        geocoder.reverse((lat, lon), **kwargs)
        # print(lat, lon, geopy_location.raw.get("address"))


def nominatim_api_test(runs: int = 1) -> None:
    """Testing nominatim over the nominatim-api library and direct DB access."""
    global lat, lon
    config_params = {"NOMINATIM_DATABASE_DSN": ""}
    locale = napi.Locales(["en", "fr"])
    with napi.NominatimAPI(environ=config_params) as api:
        for _ in range(runs):
            lat += 0.001
            lon += 0.001
            # Nominatim expects x, y: meaning long, lat
            result = api.reverse(
                napi.Point(lon, lat),
                address_details=True,
                max_results=1,
                layers=napi.DataLayer.ADDRESS,
                max_rank=27,
            )
            if not result:
                continue
            # Since HTTP results are also localized (2-3% overhead)
            locale.localize(result.address_rows)


@cache
def get_traccar_geocoder() -> Traccar:
    """Create Nominatim client for the location service."""
    connection_string = ""
    traccar_api_key = ""
    return Traccar(
        domain=connection_string,
        adapter_factory=RequestsAdapter,
        timeout=3,
        scheme="http",
        api_key=traccar_api_key,
    )


runs = 100

# main
if __name__ == "__main__":
    """Run with python -m dataworker.utils.location_perf"""
    print("Over http")
    # timer = timeit.timeit("from dataworker.utils.location_perf import nominatim_http_test;nominatim_http_test(nominatim, 20)", setup="from dataworker.utils.location_perf import get_nominatim_geocoder;lat=1.6;lon=32.8;nominatim=get_nominatim_geocoder()", number=1)  # noqa: E501
    timer = timeit.timeit(
        "geopy_http_test(nominatim, runs)",
        setup="nominatim=get_nominatim_geocoder()",
        number=1,
        globals=globals(),
    )
    print(timer)
    print("Over API")
    # timer = timeit.timeit("from dataworker.utils.location_perf import nominatim_api_test;nominatim_api_test(20)", setup="lat=1.6;lon=32.8", number=1)  # noqa: E501
    timer = timeit.timeit("nominatim_api_test(runs)", number=1, globals=globals())
    print(timer)
    print("Over Traccar")
    # timer = timeit.timeit("from dataworker.utils.location_perf import nominatim_http_test;nominatim_http_test(nominatim, 20)", setup="from dataworker.utils.location_perf import get_nominatim_geocoder;lat=1.6;lon=32.8;nominatim=get_nominatim_geocoder()", number=1)  # noqa: E501
    timer = timeit.timeit(
        "geopy_http_test(traccar, runs)",
        setup="traccar=get_traccar_geocoder()",
        number=1,
        globals=globals(),
    )
    print(timer)

And the output and speed are, when setting runs/loops to 20:

Over http
connecting to location service at {}:{} localhost 8080
1.531380000000354
Over API (4x slower)
6.158920083020348
Over Traccar ("only" 25% faster)
connecting to location service at {}:{} localhost 3000
1.1985314580379054

And to 100:

Over http
7.856885084009264
Over API
33.84674679202726
Over Traccar
5.897717709012795

Best, Matthieu

[lonvia]

If you are after speed you should work with the async version of the API NominatimAPIAsync. NominatimAPI is just a thin convenience wrapper around the async version not made with performance in mind.

With the async version you can have multiple requests in parallel in flight but don't expect too much parallelization. More than 5 won't show much speedup anymore. Go for multiprocessing instead to make full use of all available CPUs/RAM.

[MRigal]

Hi @lonvia

Thanks for the answer. I was mentioning that I was gonna look into parallellization afterwards.

But for now, isn't it a surprise that the method without HTTP overhead is that much slower??? Why should I bother with a x5 on async if the nominatim-api is giving a >4x slowdown on individual queries whereas it should be faster? This is a bit the reason why I opened this discussion...