Conformal Willmore flow

Based on the work of Keenan Crane, this is an implementation of Conformal curvature flow using spin transformations.

Dependencies

• Eigen (header only, version 3.3.7)
• IGL (header only)
• qmake (version 5)

Dependencies (Device code only)

• CUDA (version 9.0 or greater)
• Thrust (shipped with CUDA)
• CUSP (header only)

Dependencies (Tests and benchmarks)

• Google Test
• Google Benchmark

Build

Configuration

The following environment variables are required for compilation:

CUDA_PATH : Needs to point to the base directory of your cuda lib and includes CUDA_ARCH : Your device compute capability (e.g. 30, 35, ... 50, 52 ...) HOST_COMPILER : Your local g++ compiler (compatible with cuda compiles, g++ 4.8.5)

> git submodule update --init --recursive
> qmake
> make -j

References:

[1] K. Crane, U. Pinkall, and P. Schröder, “Spin transformations of discrete surfaces,” ACM Transactions on Graphics, vol. 30, no. 4, p. 1, Jul. 2011.
[2] K. Crane, U. Pinkall, and P. Schröder, “Robust fairing via conformal curvature flow,” ACM Transactions on Graphics, vol. 32, no. 4, p. 1, Jul. 2013.

Project Structure

• The library contains a host and a device implementation, separated by namspaces.
• The host implementation is header only and was designed to feel like an extension of the popular IGL library (it follows their style guide too.)
• The device implementation requires compiling into a shared library and has been R-pathed into the tests and benchmarks for convenience.
• The project comes with 2 host samples, and one device sample. The first host, and only device sample is a demo implementation of willmore flow. The second host sample named matrix_bake, will export all matrices required by the tests and benchmarks in matrix market format.
• The project comes with a full set of host and device tests and benchmarks.
• Currently all subdirectories dump an executable in their directory.

Coding standards

• The host side follows the same style as IGL using single capital letters for parameter names of common data, and snake case for function names.
• The device side uses a similar style but due to the increased number of parameters in functions, I decided to provide full parameter names.
• Both use view types where ever possible to avoid needless copies, but also to avoid enforcing specific data types on the user.

##NOTE

• Spin positions test is failing for the DEVICE side implementation as it finds an equivalent but different solution to the linear system
• Before testing and benchmarking you must place the matrices and models folders in the test directory

Development of parallel implementation

This project was developed as a final year programming assignment, with the goal of reimplementing a sequential algorithm on the GPU, and benchmarking the performance gains. I chose to implement conformal willmore flow using spin tranformations as nature of a geometry processing project lends itself to data oriented design. I have outlined some of the more noteworthy parts of the project below.

Adjacency Matrix Indices

Overview

One of the main aspects of the project was to assemble sparse matrices in parallel. One possible approach would be to compute lists of triplets, which could then be sorted by row and column index, before being reduced. The draw back of this approach is of course using two sorts. The two sparse matrices required for this project both share the same sparsity pattern (laplacian), and we know that, all entries in the matrix will only be written to a maximum of twice (except the diagonals), so it makes sense to try and use atomics here as the number of collisions will be very low. To facilitate this, each thread working on the matrix would require an index to write out it's value, and this function provides that.

The goal is to produce the matrix column and row indices, as well as diagonal indices (useful for later), and entry indices for parallel assembly. The first two are essentially the vertex-vertex adjacency lists with added diagonals. The adjacency lists can be found by creating a list of all possible half edges and then using unique to remove duplicates. Once we've obtained them, we can find the locations where our diagonal entries should be inserted by comparing each row index against each column index and writing a one if, it is less. If we follow this with a reduce, we've obtained the amount of rows per column before the diagonal, so to finish we can add an ascending list and the cumulative valence of each row (prior to diagonals being inserted) to these reduced values and voi-la.

row_index: 0 0 0 1 1 2 2 3 3 3
col_index: 1 2 3 0 3 0 3 0 1 2
--------------------------------
compared : 0 0 0 1 0 1 0 1 1 1
--------------------------------
index : 0 1 2 3
reduced : 0 1 1 3
--------------------------------
valence : 3 2 2 3
cumval : 0 3 5 7 10
sequence : 0 1 2 3
(reduced + cumval + sequence =)
diagonals: 0 5 8 13

Handy optimizations are to pack the comparisson and reduce into one kernel using a thrust transform iterator on the way in, and then pack the final sequence and valence add in to the end using a transform output iterator, leaving us with one single kernel launch.

Given the diagonals, it is simple to produce the row and column indices by copying across the vertex-vertex adjacency lists, but making sure to skip our diagonals. Then in a second pass, the diagonals indices are copied to using an ascending sequence. In practice this can all be done with thrust and permutation iterators.

row_index: 0 0 0 1 1 2 2 3 3 3
col_index: 1 2 3 0 3 0 3 0 1 2
diagonals: 0 5 8 13
--------------------------------------
1st pass : - 0 0 0 1 - 1 2 - 2 3 3 3 -
2nd pass : 0 0 0 0 1 1 1 2 2 2 3 3 3 3

As for the regular entry indices, we use a parallel binary search method on each in each face (same order as the threads in the sparse matrix assembly kernels.) Given an edge A -> B we find the upper bound and lower bounds as the cumulative valence of vertex A, and one past A. We then perform a binary search within these bounds for B. Unfortunately this can yeild unbalanced work-loads for threads in the kernel, however it need only be computed once and executes quick enough for this purpose, especially when combined with the gains in the sparse matrix assembly.

row_index : 0 0 0 1 1 2 2 3 3 3
col_index : 1 2 3 0 3 0 3 0 1 2
cumval : 0 3 5 7 10
------------------------------
f0 : 0 1 3
lower_bound : 0 3 7
upper_bound : 3 5 10
b-search : 0 4 7

Cotangent Laplacian

Overview

The cotangent laplacian is a very useful discrete representation of a surfaces mean curvature, used heavily for this algorithm. It will be recomputed at every iteration, and so it was essential that the assembly be quick. Initially I began by launching 6 threads per face, meaning 2 threads per face edge, which directly corresponds to the amount of writes into the matrix required. This allowed for one atomic add per thread, and hence a fairly quick assembly, however the uneven number of threads per block, and the fact that threads working on the same face could be in different warps limited my ability to combat bank conflicts. My original solution was to instead have 8 threads per face, with 2 dummy threads doing no work, but aligning the rest. However I then realised that once the alignment was in place, the entire computation could be performed using only interwarp communcation rather than block-wide. This would mean I could get rid of shared memory and potential back conflicts, and instead use warp shuffling to share data between my threads. At this point it seemed wasteful to have 2 dead threads, so I settled for 4 threads per face, with one dead thread. Each alive thread would write to global memory twice, once in the upper triangular part and once in the lower. The thread communication is fairly simple, each thread loads in a vertex positon (1-per thread), and then using a warp shuffle, we subtract the neighbours vertex value to produce 3 edges. With these edges I first compute the face area, and then the final cotangent laplacian value. Writing these value back to global memory is simple since we have computed the entry indices in the previous step.

if lane < 3:
read vertex_pos
shuffle (0 1 2 -) -> (1 2 0 1)
shuffle down subtract (1-2 2-0 0-1 1-2)
shuffle donw neighbor_edge
inv_area <- 0.5 * rsqrt(cross(edge, neighbor_edge))
result <- dot(edge, neigbor_edge) * inv_area

In the real implementation I don't just kill off the 4th thread, instead I use it as temporary storage to make shuffle downs easier. The main kernel leaves the diagonals untouched, as they are easier computed in a second pass, we need simply reduce each column and write the negation of the sum.

Intrinsic Dirac

Overview

The intrinsic dirac operator is the core of the algorithm and luckily has the same sparsity pattern as the cotangent laplacian, so we can reuse the row and column indices, as well as the diagonal and entry indices for computation. The resulting computation is more complex, involving quaternion hammilton products, and is not entirely symmetrical, however the resolution wasn't too bad. Another issue I faced (unresolved) is that we can't take advantage of vectorized writes to global memory when using atomics as they're only implemented for 4 byte primitives. The final diagonal computation was also more challenging to implement, involving more variables than the simple reduce for a cotangent laplacian. To optimize this I first noted that all contributions were coming from adjacent triangles, and so could probably be modelled using a reduce. In particular, the contribution would come from the case where we use the same vertex for both sides of our edge, which after a subtraction will result in zero, so we can therefor assume that all diagonals will be purely real quaternions with a zero imaginary vector. The real part can be computed as the dot product of the two edges stemming from our vertex, plus the regular real component computed from only our change in mean curvature. After all this we can model the diagonals as a reduce by vertex triangle adjacency, where at each adjacency pair we transform the two edges containing our vertex into the resulting diagonal.

Tri <- [v0, v1, v2]
find two edges:
e0 <- v1-v0
e1 <- v2-v0
result <- (rho^2 * area / 9) + dot(e0, e1) / (4 * area)

Solving the sparse Linear systems

Overview

This project involved solving two sparse linear systems. The first called Similarity transforms, produces a quaternion per vertex that best describes it's conformal deformation, using the intrinsic dirac matrix as a left hand side. The second called Spin positions, produces new vertex positions that best fit the edges calculated using the similarity transforms. This was probably the most challenging and important stage of the project. These two processes are the slowest host functions as well, meaning it was crucial to speed them up. I ended up implementing two methods for both, one using a direct solve via the cuSolverSp and cuSparse API, and the other using an iterative conjugate gradient solver via the CUSP API.

Interestingly the conjugate gradient solve out performs a direct cholesky decomposition drastically for the similarity transforms, and beats the host version for some of the smaller meshes. The direct solve wins for larger meshes in the Spin positions step, where the iterative solve performs poorly.

Future improvements

I ran out of time before I was able to implement the mean curvature calculation and projection on the device side, and would add this next. I would also work on moving duplicate code out of the sparse matrix assembly kernels which would allow the shuffle methods to be used by other functions, such as face area calculations. Finally I would like to have used streams more as there is definitely potential to overlap computation in this project.

Benchmarks

Host

Intel® Xeon(R) CPU E5-1650 v3 @ 3.50GHz × 12 processor

name	iterations	real_time	cpu_time	time_unit
HOST_cotangent_laplacian_cube	182627	3852.71	3852.37	ns
HOST_cotangent_laplacian_spot	90	7.68602e+06	7.65249e+06	ns
HOST_cotangent_laplacian_bunny	35	2.03471e+07	2e+07	ns
HOST_cotangent_laplacian_tyra	8	7.18162e+07	6.8106e+07	ns
HOST_divergent_edges_cube	471392	1477.79	1477.58	ns
HOST_divergent_edges_spot	100	5.24034e+06	5.2395e+06	ns
HOST_divergent_edges_bunny	50	1.39971e+07	1.39957e+07	ns
HOST_divergent_edges_tyra	12	5.04251e+07	5.04111e+07	ns
HOST_face_area_cube	4344953	164.346	164.308	ns
HOST_face_area_spot	2074	339835	339751	ns
HOST_face_area_bunny	723	974836	974671	ns
HOST_face_area_tyra	226	3.1432e+06	3.14241e+06	ns
HOST_intrinsic_dirac_cube	44546	15991	15988.7	ns
HOST_intrinsic_dirac_spot	8	7.53803e+07	7.53403e+07	ns
HOST_intrinsic_dirac_bunny	1	6.25203e+08	6.25151e+08	ns
HOST_intrinsic_dirac_tyra	1	1.83794e+09	1.83772e+09	ns
HOST_mean_curvature_cube	2044611	365.646	365.569	ns
HOST_mean_curvature_spot	1228	559729	559669	ns
HOST_mean_curvature_bunny	623	1.14741e+06	1.14732e+06	ns
HOST_mean_curvature_tyra	162	4.46348e+06	4.463e+06	ns
HOST_orthonormalize_cube	912301	768.27	768.2	ns
HOST_orthonormalize_spot	5326	135622	135611	ns
HOST_orthonormalize_bunny	2243	310662	310637	ns
HOST_orthonormalize_tyra	749	934909	934832	ns
HOST_project_basis_cube	1746431	397.31	397.274	ns
HOST_project_basis_spot	11059	62670	62664.8	ns
HOST_project_basis_bunny	4811	142988	142976	ns
HOST_project_basis_tyra	1644	419267	419232	ns
HOST_quaternion_matrix_cube	64695	10676.5	10675.6	ns
HOST_quaternion_matrix_spot	24	2.96319e+07	2.96293e+07	ns
HOST_quaternion_matrix_bunny	12	5.74237e+07	5.7419e+07	ns
HOST_quaternion_matrix_tyra	3	2.02537e+08	2.02519e+08	ns
HOST_similarity_xform_cube	29636	23613.9	23611.8	ns
HOST_similarity_xform_spot	1	6.35867e+08	6.35806e+08	ns
HOST_similarity_xform_bunny	1	4.63868e+09	4.63829e+09	ns
HOST_similarity_xform_tyra	1	8.65426e+09	8.65345e+09	ns
HOST_spin_positions_cube	38234	18642.5	18641	ns
HOST_spin_positions_spot	1	6.29275e+08	6.29218e+08	ns
HOST_spin_positions_bunny	1	4.65188e+09	4.65144e+09	ns
HOST_spin_positions_tyra	1	8.61795e+09	8.61715e+09	ns
HOST_vertex_mass_cube	3144441	224.885	224.867	ns
HOST_vertex_mass_spot	1726	412928	412894	ns
HOST_vertex_mass_bunny	575	1.21601e+06	1.21591e+06	ns
HOST_vertex_mass_tyra	180	3.92145e+06	3.9211e+06	ns
HOST_vertex_normals_cube	398109	1786.48	1786.32	ns
HOST_vertex_normals_spot	370	4.03304e+06	2.02852e+06	ns
HOST_vertex_normals_bunny	262	5.30947e+06	2.79652e+06	ns
HOST_vertex_normals_tyra	118	1.05496e+07	6.1032e+06	ns
HOST_vertex_triangle_adjacency_cube	209312	2846.6	2811.03	ns
HOST_vertex_triangle_adjacency_spot	1168	696248	674157	ns
HOST_vertex_triangle_adjacency_bunny	308	2.49694e+06	2.46715e+06	ns
HOST_vertex_triangle_adjacency_tyra	86	8.45339e+06	8.39191e+06	ns
HOST_vertex_vertex_adjacency_cube	372804	1905.26	1901.45	ns
HOST_vertex_vertex_adjacency_spot	172	4.13094e+06	4.12159e+06	ns
HOST_vertex_vertex_adjacency_bunny	55	1.28761e+07	1.28478e+07	ns
HOST_vertex_vertex_adjacency_tyra	16	4.38669e+07	4.37587e+07	ns

Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz

name	iterations	real_time	cpu_time	time_unit
HOST_cotangent_laplacian_cube	271031	2576.69	2574.4	ns
HOST_cotangent_laplacian_spot	103	6.9254e+06	6.71974e+06	ns
HOST_cotangent_laplacian_bunny	42	1.6869e+07	1.62396e+07	ns
HOST_cotangent_laplacian_tyra	12	5.43377e+07	5.20702e+07	ns
HOST_divergent_edges_cube	261742	2713.79	2711.13	ns
HOST_divergent_edges_spot	90	7.78507e+06	7.77556e+06	ns
HOST_divergent_edges_bunny	34	2.00418e+07	2.00014e+07	ns
HOST_divergent_edges_tyra	7	9.34462e+07	9.31885e+07	ns
HOST_face_area_cube	6017563	113.593	113.481	ns
HOST_face_area_spot	2523	280010	279535	ns
HOST_face_area_bunny	878	805238	803422	ns
HOST_face_area_tyra	270	2.583e+06	2.57878e+06	ns
HOST_intrinsic_dirac_cube	47654	13423.8	13411.1	ns
HOST_intrinsic_dirac_spot	10	6.21724e+07	6.20564e+07	ns
HOST_intrinsic_dirac_bunny	1	5.33196e+08	5.32015e+08	ns
HOST_intrinsic_dirac_tyra	1	1.6005e+09	1.59639e+09	ns
HOST_mean_curvature_cube	3933690	178.399	178.214	ns
HOST_mean_curvature_spot	1458	479014	478333	ns
HOST_mean_curvature_bunny	756	978688	976697	ns
HOST_mean_curvature_tyra	158	4.39168e+06	4.38173e+06	ns
HOST_orthonormalize_cube	2125151	330.327	329.96	ns
HOST_orthonormalize_spot	8477	83593.6	83457.2	ns
HOST_orthonormalize_bunny	3731	189577	189290	ns
HOST_orthonormalize_tyra	1255	565450	564393	ns
HOST_project_basis_cube	5539554	128.969	128.826	ns
HOST_project_basis_spot	18190	40110.3	40037.7	ns
HOST_project_basis_bunny	8605	84039.3	83884.8	ns
HOST_project_basis_tyra	2904	233260	232939	ns
HOST_quaternion_matrix_cube	78228	8942.42	8933.33	ns
HOST_quaternion_matrix_spot	29	2.40185e+07	2.39839e+07	ns
HOST_quaternion_matrix_bunny	15	4.68857e+07	4.68207e+07	ns
HOST_quaternion_matrix_tyra	4	1.63473e+08	1.63205e+08	ns
HOST_similarity_xform_cube	38645	18438.3	18414	ns
HOST_similarity_xform_spot	1	7.42056e+08	7.38969e+08	ns
HOST_similarity_xform_bunny	1	4.0992e+09	4.08846e+09	ns
HOST_similarity_xform_tyra	1	7.66838e+09	7.6493e+09	ns
HOST_spin_positions_cube	49689	13943.9	13925.5	ns
HOST_spin_positions_spot	1	5.45467e+08	5.44281e+08	ns
HOST_spin_positions_bunny	1	4.34899e+09	4.33687e+09	ns
HOST_spin_positions_tyra	1	7.72303e+09	7.69932e+09	ns
HOST_vertex_mass_cube	4696537	150.733	150.515	ns
HOST_vertex_mass_spot	1984	345572	344981	ns
HOST_vertex_mass_bunny	730	979333	977439	ns
HOST_vertex_mass_tyra	222	3.39383e+06	3.38649e+06	ns
HOST_vertex_normals_cube	603713	1159.48	1158.22	ns
HOST_vertex_normals_spot	1018	5.08585e+06	1.03785e+06	ns
HOST_vertex_normals_bunny	415	8.53295e+06	1.69286e+06	ns
HOST_vertex_normals_tyra	147	2.08555e+07	5.71142e+06	ns
HOST_vertex_triangle_adjacency_cube	450150	1691.17	1687.71	ns
HOST_vertex_triangle_adjacency_spot	957	672810	640440	ns
HOST_vertex_triangle_adjacency_bunny	366	1.85957e+06	1.8288e+06	ns
HOST_vertex_triangle_adjacency_tyra	102	6.66418e+06	6.64907e+06	ns
HOST_vertex_vertex_adjacency_cube	454305	1478.19	1476.08	ns
HOST_vertex_vertex_adjacency_spot	183	3.80413e+06	3.79766e+06	ns
HOST_vertex_vertex_adjacency_bunny	62	1.09962e+07	1.09678e+07	ns
HOST_vertex_vertex_adjacency_tyra	19	3.6735e+07	3.66314e+07	ns

Device

Quadro K2200

name	iterations	real_time	cpu_time	time_unit
DEVICE_adjacency_matrix_indices_cube	1859	341886	340272	ns
DEVICE_adjacency_matrix_indices_spot	952	815516	811983	ns
DEVICE_adjacency_matrix_indices_bunny	648	1043000	1040070	ns
DEVICE_adjacency_matrix_indices_tyra	303	2308040	2305360	ns
DEVICE_cotangent_laplacian_cube	2636	266425	264868	ns
DEVICE_cotangent_laplacian_spot	1822	389558	387782	ns
DEVICE_cotangent_laplacian_bunny	1180	592784	590895	ns
DEVICE_cotangent_laplacian_tyra	250	2780910	2779790	ns
DEVICE_divergent_edges_cube	2755	250017	248657	ns
DEVICE_divergent_edges_spot	1829	388904	386151	ns
DEVICE_divergent_edges_bunny	1227	573293	571326	ns
DEVICE_divergent_edges_tyra	416	1661450	1661310	ns
DEVICE_face_area_cube	174640	4013.78	4013.42	ns
DEVICE_face_area_spot	39931	18190.5	18189	ns
DEVICE_face_area_bunny	10000	70404.2	70398.4	ns
DEVICE_face_area_tyra	10000	228716	228697	ns
DEVICE_intrinsic_dirac_cube	11973	55211.1	55206.5	ns
DEVICE_intrinsic_dirac_spot	605	1157520	1156930	ns
DEVICE_intrinsic_dirac_bunny	265	2778810	2767580	ns
DEVICE_intrinsic_dirac_tyra	58	11694600	11693600	ns
DEVICE_quaternion_matrix_cube	64005	10361	10360.2	ns
DEVICE_quaternion_matrix_spot	1619	432756	432711	ns
DEVICE_quaternion_matrix_bunny	825	844616	844546	ns
DEVICE_quaternion_matrix_tyra	278	2.40125e+06	2.40105e+06	ns
DEVICE_similarity_xform_direct_cube	410	1.65968e+06	1.65722e+06	ns
DEVICE_similarity_xform_direct_spot	1	3.72199e+09	3.72164e+09	ns
DEVICE_similarity_xform_direct_bunny	1	1.48061e+10	1.48048e+10	ns
DEVICE_similarity_xform_direct_tyra	1	9.21995e+10	9.2191e+10	ns
DEVICE_similarity_xform_iterative_cube	354	1.97964e+06	1.97947e+06	ns
DEVICE_similarity_xform_iterative_spot	1	8.37923e+08	8.35415e+08	ns
DEVICE_similarity_xform_iterative_bunny	1	1.60284e+09	1.59807e+09	ns
DEVICE_similarity_xform_iterative_tyra	1	4.12793e+09	4.12634e+09	ns
DEVICE_spin_positions_direct_spot	1	3.68252e+09	3.68218e+09	ns
DEVICE_spin_positions_direct_bunny	1	1.4813e+10	1.48117e+10	ns
DEVICE_spin_positions_direct_tyra	1	9.26087e+10	9.25993e+10	ns
DEVICE_spin_positions_iterative_spot	1	3.20449e+09	3.19223e+09	ns
DEVICE_spin_positions_iterative_bunny	1	2.43237e+10	2.42893e+10	ns
DEVICE_spin_positions_iterative_tyra	1	4.5125e+10	4.5104e+10	ns
DEVICE_vertex_mass_cube	1850	382962	381300	ns
DEVICE_vertex_mass_spot	774	918686	914777	ns
DEVICE_vertex_mass_bunny	715	985748	981242	ns
DEVICE_vertex_mass_tyra	550	1.27652e+06	1.27083e+06	ns
DEVICE_vertex_triangle_adjacency_cube	7564	83150.4	83142.5	ns
DEVICE_vertex_triangle_adjacency_spot	975	645653	644782	ns
DEVICE_vertex_triangle_adjacency_bunny	687	951790	950354	ns
DEVICE_vertex_triangle_adjacency_tyra	341	2.00665e+06	2.00445e+06	ns
DEVICE_vertex_vertex_adjacency_cube	1754	402834	401607	ns
DEVICE_vertex_vertex_adjacency_spot	328	2.11945e+06	2.11526e+06	ns
DEVICE_vertex_vertex_adjacency_bunny	205	3.42353e+06	3.41836e+06	ns
DEVICE_vertex_vertex_adjacency_tyra	78	8.39362e+06	8.38729e+06	ns

Quadro M3000M

name	iterations	real_time	cpu_time	time_unit
DEVICE_adjacency_matrix_indices_cube	7884	79085	78952.7	ns
DEVICE_adjacency_matrix_indices_spot	3765	186365	186057	ns
DEVICE_adjacency_matrix_indices_bunny	1981	354997	354429	ns
DEVICE_adjacency_matrix_indices_tyra	698	1.00454e+06	1.00289e+06	ns
DEVICE_cotangent_laplacian_cube	19028	36727.9	36673.4	ns
DEVICE_cotangent_laplacian_spot	7318	95927	95779	ns
DEVICE_cotangent_laplacian_bunny	3788	185237	184952	ns
DEVICE_cotangent_laplacian_tyra	639	1.09654e+06	1.09491e+06	ns
DEVICE_divergent_edges_cube	22758	31024.4	30975	ns
DEVICE_divergent_edges_spot	5095	137633	137418	ns
DEVICE_divergent_edges_bunny	2589	270829	270412	ns
DEVICE_divergent_edges_tyra	714	882609	881253	ns
DEVICE_face_area_cube	242575	2905.48	2902.24	ns
DEVICE_face_area_spot	43658	17166.9	17149	ns
DEVICE_face_area_bunny	10000	59671.9	59607.6	ns
DEVICE_face_area_tyra	10000	167694	167522	ns
DEVICE_intrinsic_dirac_cube	12720	48998.3	48921.5	ns
DEVICE_intrinsic_dirac_spot	1224	571206	570304	ns
DEVICE_intrinsic_dirac_bunny	546	1.28079e+06	1.27895e+06	ns
DEVICE_intrinsic_dirac_tyra	115	5.41181e+06	5.40575e+06	ns
DEVICE_quaternion_matrix_cube	73965	8841.74	8831.27	ns
DEVICE_quaternion_matrix_spot	2955	237677	237398	ns
DEVICE_quaternion_matrix_bunny	1530	458183	457665	ns
DEVICE_quaternion_matrix_tyra	540	1.29391e+06	1.29254e+06	ns
DEVICE_similarity_xform_direct_cube	585	1.18767e+06	1.18497e+06	ns
DEVICE_similarity_xform_direct_spot	1	8.58772e+08	8.57566e+08	ns
DEVICE_similarity_xform_direct_bunny	1	2.73471e+09	2.7312e+09	ns
DEVICE_similarity_xform_direct_tyra	1	7.14028e+09	7.13095e+09	ns
DEVICE_similarity_xform_iterative_cube	422	1.63953e+06	1.63654e+06	ns
DEVICE_similarity_xform_iterative_spot	3	2.18979e+08	2.18621e+08	ns
DEVICE_similarity_xform_iterative_bunny	1	7.19855e+08	7.17361e+08	ns
DEVICE_similarity_xform_iterative_tyra	1	2.08458e+09	2.07955e+09	ns
DEVICE_spin_positions_direct_spot	1	8.20441e+08	8.1929e+08	ns
DEVICE_spin_positions_direct_bunny	1	2.71461e+09	2.71119e+09	ns
DEVICE_spin_positions_direct_tyra	1	6.88368e+09	6.87474e+09	ns
DEVICE_spin_positions_iterative_spot	1	1.39873e+09	1.39645e+09	ns
DEVICE_spin_positions_iterative_bunny	1	1.09265e+10	1.08924e+10	ns
DEVICE_spin_positions_iterative_tyra	1	2.23644e+10	2.23161e+10	ns
DEVICE_vertex_mass_cube	9017	72878.7	72766.8	ns
DEVICE_vertex_mass_spot	2724	256301	255283	ns
DEVICE_vertex_mass_bunny	2391	294982	293866	ns
DEVICE_vertex_mass_tyra	1370	512385	510719	ns
DEVICE_vertex_triangle_adjacency_cube	9364	68021.9	67925	ns
DEVICE_vertex_triangle_adjacency_spot	1339	470203	468639	ns
DEVICE_vertex_triangle_adjacency_bunny	1007	647694	645818	ns
DEVICE_vertex_triangle_adjacency_tyra	508	1.35423e+06	1.35101e+06	ns
DEVICE_vertex_vertex_adjacency_cube	4683	146918	146687	ns
DEVICE_vertex_vertex_adjacency_spot	501	1.36479e+06	1.36066e+06	ns
DEVICE_vertex_vertex_adjacency_bunny	338	2.0472e+06	2.04122e+06	ns
DEVICE_vertex_vertex_adjacency_tyra	132	4.88977e+06	4.88117e+06	ns