#d3-geo

d3_geo_voronoi_rs

A port into rustlang of the javascript library d3-geo-voronoi

3 releases

0.1.2 Jan 22, 2023
0.1.1 Jan 14, 2023
0.1.0 Dec 31, 2022

#28 in Geospatial

Download history 27/week @ 2022-12-31 3/week @ 2023-01-07 28/week @ 2023-01-14 32/week @ 2023-01-21

90 downloads per month

MIT license

62KB
1.5K SLoC

d3_geo_voronoi_rs

rust 2021 edition.

About

This is a port of the d3-geo-voronoi library into a RUST library.

As a example the library can be used to compute the following delaunay mesh. Delaunay mesh from a set of random points on a sphere

( computed from 6,000 points on a sphere selected at random )

Currently we have 84% test coverage ( as reported by cargo tarpaulin -o Html )

A collection of d3 sub packages is being ported to rust.

Performance Profiling

Demo Page

The original javascript library has a benchmark in the form of web page which records the number of frames displayed per second. For comparison the benchmark has been ported.

  • javascript - d3-geo_voronoi/src/benchmark/sphereCanvas.html
  • rust - rust_d3_geo_vornoi/benchmark.

Measuring the performance of a library is compilcated, as different applications employing the library may see different results. Desktop and mobile perfomance may differ.

There are traditionally two way of measuring increases in performance :-

A) Speed: By asking how long it takes to perform a certain computation?

B) Throughput: By asking how much more work can I perfom in a given time?

A and B are ideally linearly related, but often high throughput requires more memory which may increase page swapping. Javascipt uses garbage collection, rust does not. In garbage collected environments, the dynamics of a collectors behaviours may cause the figures reported by A and B to diverge.

Here are the results for the benchmark :-

A) When I tune the benchmark for 60ps, I find the javascript can render 600 points in 16ms. The rust version performs the same workload in 11ms. ( a 31% speedup ).

B) When I increase the number of points given to the RUST version to render, I find I can render 826 in 16ms. An increase in throughput of 37%.

I am currently looking to add more benchmarks, a diverse collection of example application code, will give greater confidence in what to expect.

Profile Target

This workspace contain a binary "profie_target" which outputs the result of a computation similar to that of the demo_page. Before API finialization - I am currently using cargo flamegraph to identify any obvious optimizations.

from rust_d3_geo_voronoi

cargo install  flamegraph
cargo flamegraph -- profile_target

Further Development

Known bugs

Currently the demo works only then f64 is used as the floating point type. [For f32 the cell integrity is broken as some of the cell appear to takeup the whole sphere.] To be ported:-

contour.js and geo-contour-test.js

Currenly there is a failing test suite geo_voronoi_test.rs "geoVoronoi.hull does not break on difficult polygons"

Instructions for building the benchmark

I'm using wasm pack to package the following packages into a single wasm file. rust_d3_geo, rust_d3_delaunay.

The application displays a delaunay mesh of a large number of cells onto a sphere.

  • To build and start the web server:-
cd benchmark
wasm-pack build
cd www
npm install
npm run start

The last command automatically starts your web browser.

For benchmarking, to obtain best performance

cd benchmark
wasm-pack build --release
cd www
npm install
npm run build
serve dist/

and then host rust_d3_geo_voronoi/benchmark/dist directory before viewing in a browser. Timing specific information is output to the console.

Dependencies

~13MB
~257K SLoC