Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Ideas for improved expire mechanism #1662

Open
joto opened this issue Mar 18, 2022 · 1 comment
Open

Ideas for improved expire mechanism #1662

joto opened this issue Mar 18, 2022 · 1 comment

Comments

@joto
Copy link
Collaborator

joto commented Mar 18, 2022

This issues collects some thoughts about tile expiry and how it can be improved. Details can be discussed in additional issues, this should only collect the broader design issues.

Problems with current expiry mechanism

  • For polygons the whole bounding box is expired, this is wasteful. A solution has already been implemented by @Nakaner, but was never merged. See Rewrite tile expiry (management of expired tiles) #709.
  • If the polygon bbox is higher or wider than 20000m (or whatever is set with --expire-bbox-size) only the boundary is expired, this is a somewhat crude measure that will not always work.
  • It is unclear whether and how the expiry mechanism works with anything but EPSG:3857 geometries. We haven't seen any complaints, so maybe this is a non-issue, but it should be clear what to expect from osm2pgsql.
  • The tile overlap at the tile boundaries is currently set to 10% of the tile size and not configurable. Do we need that?

What else do we want?

  • It would be nice to be able to set different expire "strategies", for instance whole polygon vs. boundary based on knowledge about how the result will be rendered.
  • The union of the old geometry and new geometry of a changed feature is always used for expiry, even if a large geometry changes only a little bit. This is wasteful, there can be many tiles which will not change. It would be nice if we can use the symetrical difference between those geometries instead of the union to decide what to expire. This needs to be configurable, because small changes in a geometry can lead to larger changes elsewhere, for instance when the center of the geometry changes and the label is rendered somewhere else.
  • We are already working on being able to generate more and different types of geometries from the data, for instance the centroid of a polygon, or specialized geometries from relations. The expire mechanism should work for these, too.
  • The expire mechanism was developed back in the time when everybody did raster tiles. But today we are often creating vector tiles, where the change in one feature will only affect the features in the same layer in the vector tile but not all the other layers. So it should be possible to do expiry per layer, i.e. per database table defined in the flex output.
  • Is it enough that we create those expire files? Maybe we need tools to make them more useful, for instance to merge expire files etc. Do we want to have those lists in the database instead? How are they used and what can we do to make life easier for users?

Outline of an improved design

All the topics mentioned above lead me to a design that looks somewhat like this:

  • For every database table in the flex output there is some configuration that tells osm2pgsql how to convert the old and/or new geometries of the feature into a list of tiles.
  • This configuration is not static, but can change based on the tags of the feature. You can then, for instance, handle large polygons with a name differently than those without a name, so the label placement is not messed up.
  • Expire lists will be generated for each table individually or maybe for groups of tables. They can be merged to one list later or kept separate. This can be used to update only some layers in vector tiles or it can be used, for instance, to prioritize re-rendering of more important changes. An alternative but ultimately equivalent option would be to still have one expire list, but allow attributes on the entries.

For backwards compatibility the defaults should be, as far as possible, whatever the code does now.

The pgsql and gazetteer output will not change.

See also

@gravitystorm
Copy link
Contributor

The list above sounds good to me, and I'm particularly interested in the symmetrical difference based expiry for large polygon features (since OSM has a lot of giant ice sheets, protected areas, admin boundaries and other things that change shape often but without needing to refresh everything within the entire unioned extent). I could add "outline expiry" to the list of options, which is a bit like the symmetrical difference but only along the perimeters of the polygons (useful where they are only stroked and not filled, so no need to expire the zone between the old and new boundaries) but I suspect the real-world usefulness of this concept is limited, given the number of polygon changes that would move edges more than typical z14-ish expiry-tile sized distances.

The one other topic to consider is per-feature buffering for expiry. For example, if a place name changes, then not only the tile that contains the point needs expiring, but also other tiles within a certain radius from that point will need expiring too, since labels will generally span multiple expiry-tiles. Feature buffers are also needed for polygons and lines (either for boundaries/lines drawn with a thickness, or for labels along boundaries/lines), but place label points illustrate the need the most.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

2 participants