DOCSLIB.ORG

1 2 3 1 2 3 This Paper Presents the Design, Implementation and Evaluation of the Etree, a Database-Oriented Method for Large

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
1 2 3 1 2 3 This Paper Presents the Design, Implementation and Evaluation of the Etree, a Database-Oriented Method for Large ETREE — A DATABASE-ORIENTED METHOD FOR GENERATING LARGE OCTREE MESHES ¡ ¢ Tiankai Tu David R. O’Hallaron Julio C. Lopez´ £ Computer Science Department, [email protected] ¤ Computer Science Department and Electrical and Computer Engineering Department, [email protected] ¥ Electrical and Computer Engineering Department, [email protected] Carnegie Mellon University, Pittsburgh, PA, U.S.A. ABSTRACT ¦¨§ © § ! ©#"$&%'© () * ()+,-© ./012/*#3 © ./4.56§ 87:9<;77:%=> -,$? @A.$© B0()§!.+85C.$D*#-"/ ./3@[email protected]() §4"/!,© .$&HJIK3!D( © L©#BM© .8( $ L$L.EG.18 -,$? F N3 E:3!FO 5C.$(P*#* .E./ :,© ./! Q?RFS3 :R!© !"§ -,$? $ /HUT03! WV¨.X -,$? $ E:§! ©#S3 ¨YZ§!*#© !BQS+3 /+$[§!\]@^ .©# !_)$) N.`§ a.E,+ 6.$X!© bHcT0a©#.+3 EUdV=.WV¨. VJE:§! ©#S3 'Ye$3!.B2+© "f-©#.$F)* .EB$*g?*#$ E©#!" .h/ + =§!K E©#*i!B).$5j() §)"/ ,-©#.$&H]kc* ©#()© R 2$$* 3-© ./X 3 "/"$ N ¨§-¨§ a`()§ .+)© 6GlgE© 2f V6R>.5m"/!,© " 2f:RF*#"$h.E() §! hn<op qGrQ\sVU©t§OuBqp v ()© *#* © ./w* ()+ ,x¨.$M)()().R+@W* © ()©tB ( $E,§ © nNu-yz {F\6x:H |[}+~ih/ Ki/-}+}0M}B]j}+-}}'Cj}+ i/-}+}'j4&&C!BCmmCi/¨ Cjfjj]-}+} 1. INTRODUCTION ( $b/a©t= ./ © ? * `. N.`*#"$Q() §! ].$ E./+2f© ./ $* !© b+ Hm¯j-"/`( $© G()().$R)E$ E©t© `E$F .2+©#!K5C@ 5E© 2f>EB$E,§ X5C.$ § >!,1 N.BJ./°!© bH±`4© !@ ¦¨§ © D© $L_E©t©#!"w()./()5.D§ X() §O"/ ,-©#.$ EB BN/I²§!./3!"/§! 3!( $bf ©tD .$ ©#?!* [.M N$( E.$()(3 !©tdRHaQ© bFEB $E© WRw© Q_ * .+!© !"G> !© Eh *#"$ $()./3! K.$5¨ -,X© .[()().R>-Q, Q§ !@ ? ©tU© a * 3 ()()© !"!%VU©t§F"/© "/$?R+ U.$5' N.$,"/B2/© *? * !./$E,§F( $© G()().$RD, N5C`,- H 5.3 !QD§ ./3! $ 8./* *# H¨a§ $()©#()$%g( @ 3!w``W!© bE,§ !./* ./"R$"$"$"/ [?.$§s N.$,"/ «K.BV=2fB%/© m© m!©t³)E3!*tm.K©#() !* ()'$./[email protected]@AE.$U !@ $ >/I ?VU©#+§F.G .2+©#!§+3 B `.5="$© "f$?R+ !./$E,§>!3!K.§!© "/3 *#-© WRF 3!K.$5'()./ NU() § H .,?R 6.$55$ N` N.$,$"$5.$a.$ *tR U.$5j§ ./3! $ ! ¬ .3 -*tR%f§ a © () * © E©tdRX /!$ !,? © * ©tdR).5j§ a.E@ .$5&./* *# H]¦mR © EB*``dsN/Is§!./3!"/§! 3!anNuBy$zh{F\6 ,x 8 N3 E3w"/© 2f G3 [ .$()w§ ./ w§-GV=ME$³D@ © [ © ()© *#F.OdR !©#E$*Q( ©#s()().$RL§!./3!"/§! 3!MnNuB¡$¡ E© *tRX N.$$ X© 2f.E:() §[ N.B[.$>!© bH {F\6- ,x[¢ u:£^H4a5DRB- .5K N,"/-© ./&%=Q`Q{P !© E §B2f * 3 ()()i%i5C./(¥¤q/¡//{F\¦.[*# § $4¤u-/{F\a% d§!©# j $ :B%V== j§!Q7:9<;7,7:%f`!,?$ :@W.© B VU©t§G( © )()().$R ©#§ ¨./)WR! !© EB$* NR N() ]©#!EB ©#!" ()§!.+5C.$m"/!,© !"*-"/6.$3!@A.$5@WE.$6.E6() § H ?RF>.$,K.5'( $"$ ©t3.2/`§! NK 2/,$*iRB H ¦¨§ KbfR)©#!h© ¨._+ ,? KE,§ ©#S3 =. 3! !@ ` >.$5¨E./3! $%c¨¨k'©ª B8E./© 3! K.[!./3!? * 2fR .$j() §"/ ,-©#.$&HT1]3! m§!U´ µ¶g7·$;¨¸¹ ·/º$9<;77=E,§!@ uBz().$+§! %$VU©t§)E* .E,b, ].-2fau`rK«K§6§!6 .$(F%f$ ©#S3 h.F$ © "$1.FBE:§M.E,$hG3! ©#S3 b/Rw§!@ yDrK«`§( $E,§ © UB2$$© *#$?!*#$H E.+ `©t a* .EB© ./M$ [ © §/%g[ N.§!.E,$ a© w V¨*#*t@Ab+ .BVU ,? [ N3 E:3!)Y»§ F¼a½A9<;77:H4d4.$@ ¦¨§ XE,§ !./* ./"R1 ! 3 "$"/ NDF"/..+O./ ! .$3 !©tdR !:K.X/! a§ E©#$*c!B>.$5m.Eh() §>"/ @ .)_ * .$© a.$3!@A.$5@WE.$E,§ ©#S3 U5C.$`() §F"$ ,-© ./&H © .$&%V¨!2f* ./ dV=.D VsE:§! ©#S3 ]Y¾·$¹+9A¿)¶·$ÀBµ#Áf·$½ ¬ Nm¨¨k'©K c !.-2+©#!'§ ]E./() !3!,© .$$*f§./3!"/§ !3!&. 9<µ^¿$¶0$ 4´ ¿B·/´'÷/´ ·¶Âµ¶ÁG.G 3! .$K.E@A* 2f*c./ @ EB-$ ­!Q§ () §iHm®'_ !*#.+© " !© b EB $E© © © .$ Ha* *j§ E.$() ./ + `© () * ()BG©#F§! ©t§ ( $EE.$()().+ - j§ ].E]©#§ aÀBµ;,9<¹ ·$´ )7 )¿$;¡ $% 7:9<;77 ´ µ^Ã;·$;¡ HDaM !*#© EB-© ./0EBM© +2f.$bfD* ©#?,R $1./ ,-©#!"F NR N( 5<E© * © WRM§ $? * 0$ ! * © EB@ 53! E© .$GEB* *# 6.h( $ © !3 *#`$G.EQ() § N.BG.$ © ./D.*#* .EB-K(h3 E,§h().a()().$R§DVU§- m §R N@ !© bH]¦¨§ *#© ?,R>3!.$( © EB$* *tRG 5.() a:_!@ © EB$* *tRB2/©#*#? * /HL¦¨§ G2+© 3 $*6()().R03! § X §R N@ © 2fK.$ !© ()© §B© .$X.© () !.-2fU§ U3 ! © "© ()KD@ © EB$*a()().R4³)E© *tRL?+RO© "0©tX GMEB$E,§ [5C.$ !3!E § G!© b0$IhH]IK3!h_ © () §!.-V §hVU©t§ $8$ K E N.$B>./8©# b%b/ © !")./ *tRF§!$E@ § aa()§!.+i%©t=,bf =$?./3Uyp v§ .$3! m."$ :, © 2f`B 6©# !§+R © EB*()().$RHj¦¨§ © 6()E,§ © ( V¨.$b+ D2fRX*#"$­ ©t* ()+U.E:() §0n'o!p q rQ\JVU©t§ © * * R°$ J$3./( -©#E$* *tR%6VU© §!./3[R°© 2f© ./ uBq+p vQ()©#* * © ./)* ()+ ,xj.$)K( E:§!©#!=VU©t§D./!*tRGuBy$z{F\ 5C.$( §!F$ ! * © EB© .$ ./"$,(FH4«K.BV¨2fB%m©t5K§ G$* * .$@ §R © EB$*i()().RH EB-Bh2+©t3*()().$RQ5'_EB! §!= §R © EB$*+()().R $ 8§!D -,[EE h)!.$* .EB* ©#§Bi%' 2/D NV6 !@ ¢ E© ./ yO?!© ¤£!R !© E3! FdV¨.°!©tlgFV¨R! >.5D"$!@ © !"1.$5Q -,M?WV¨4§ [!© bL$ 4§![()().R0VU© *#* ¢ ,-©#!"O.Ew() §! H E© ./JqO! E© ?>§ >: .EE3B%fVU§ © E,§&%+© 3&%fVU© * *§+3!'§ 6 :5.$( Ea.$5§! ¢ ()§!.+iH E© ./8oG K§ § h* © ?!,-R8$ © [email protected]* "/.$©t§!( © "/!©t­EB+*tRH8¦¨§!5./%]$O© !@AE. ¢ ©t )E./() .$ H E© ./¦¥w2$$* 3- )2/-© ./3 E $* "$.$©t§ ( © U !,$E:©#E$* *tRF()().R@A?.$3 gH .$5c§!* © ?!,-R[VU©t§>$>:@A? BG­!©t* () ¢ () §G"/!,.BH E© ./FvE./!E* 3 U./3!UV=.$bH `O.$3!@A.$5@AE.$G()§ .+g%].$O§ X.$§ :D§g%]3! h§! ()().R0© E*tR4$ )>EBE:§!G5C.$D§!G© b+@^ ©#D.E@ H`¦¨§!h © §.$5m§ .E() §>© `§+3! `© b+@A?.$3 2. OCTREE MESH GENERATION © NB$F.$5m()().R@A?.$3 gH]¦¨§ E©t© EB$*© 3!h© U.G@ E©#!VU§!©#E,§> -K.5'§ .E § .$3 *#[?EB$E,§ F©#F§! ` .E$* "/.©t§ ( ¢ y-£E3! © 2f*tR 3!?g!© 2+© 6 !.$?!@ ()().RF . §K()./ NQ , EE EB8!©tE*tR>B$ * ( !.$( $© F© .D© "/§`BS3$*& © §.E,$ a3 © *&E:,$© 5C.$(².$aV6©tQ.§ Q()().$RH .$*#3© ./1* 2/*c© $E,§ © 2fiH¬© "/3Guh© $8.E)@ E.$() ./ ©t© ./0.5aGdV=.$@W!© ()! ©#.$*=./( $© iHwn^¬ .$E.$!@ IK mEB!©#!m ./* 3!© ./h© &.a3 '§ `¿$¹+9^½d¿¨:½d¿$;7¿$µ¶!9W7:; 2f!© E$%$V=63 ¨.EU$.E,$c.a5'.S3 / ()§!.+M¢ -£^% § U© %$E,§[© !@AE. ./© a©# U( B . $ [S3$,+B%+ E© 2f*tR[© [§!© 6 $ :BH x $w.$3!@A.$5@WE.$ ./© Q© F§ 5.( .5ºµ ¨·BÁ7¶ ¹ D½ Ã,7:;¿ ! 7:9¨":H4¦¨§ X./ ,-© ./L.$5U5.$*#* .BVU© "O> .$©#© $>© @WE.$$* "/.©t§ ( ©# U,$! N5.()BG.) b+© "XF.$l@ .$1G!© b> "/$>© 2f§ , ./?#NEBHD¦¨§! $ ! * © EB© .$X ./",$() m § ./3!*# ( bfU, "$()'.!@ h m 3!w§-F§ 8./3@[email protected] .$©# [M .$[ EB:B ,$ !.$()* R[./8!© bF $"$ HI`§!VU© /%§ 5.( $!E *#!ERH6¦¨§!© K()§!.+i% a b c i j k l VU© * *?!./()© B[?R[!© bX/I § .$3 "$§XE./ E !3 $* *tR) © () * /%+© ¨ .¨B NRD.©#() !* ()BH ` X§!K 3 *ta© U.$5C>$ ! * © EB© ./@A E©t­E/H d e f g : preorder traversal of leafs 3. THE ETREE METHOD Figure 1: Quadtree decomposition of a domain. ¦¨§ F! © "/"/./$*a.$5K§!F[©# D.M !.-2+©#!F8"/!,$* ()§!.+w5C.$h³)E© *tR8"/!,© ">*#-"/ .E)() §! ./3.$56E./HFIK3!$ ! !./$E,§0© .[*#2f,$"$X$8_+ dF§!B .$5]() §F"$ ,-© ./&%i.ED!E./() .$ © © .$ -,$? $ OE,§ ©#S3 w.$ + 8§!4 E©#$*D!B .5 § [?0 3 EE N53 * N,-"$R°5.$["/!,© !"L§@ () §)"$ ,-© ./&Hma ¨Q 3!* B% !*#© EB-© ./ =EB$ ( $!© !@ !© ()! © ./*¨3 ! N3 E3B1() §! H8dO ,$E© E/%'§! 3 *#-Q$ .EK() §)?RD © () !* R)S+3!R© "Q§ ` -,$? $ dV=.G©tlg`V¨R! K.$5m3 © " § .ED -,) N3 E@ © NB$[.$5E:§ $ © "D§!Q ./© H 3!$H8IK )V6R1©# .FV6- 4§!)* B5`.E,$ .w./?!,© ,§ B+,$*+* () ¨¢ q!%-o/£^H¦¨§ ¨.§ cV¨BR© .`3 ]§! ¬© "/3[y[ §!.BVU §!) !.E .$5U"$ :,© "wF() §M3 N@ * B5j.E,$ 6 =­!©t`* ()+ =!©tE*tRDVU©t§!./3!=53!§! © "§ a`()§ .+gHcd)§ h¿$¶ 9<;,¹!Â9¨ N i% .E ().+!©t­ EB© ./¢ ¥%'v-£^HO¦j.w! 3!X"/..+4* ()DS3 $* ©tdR% © E./! N3 Ew© w§ h $()hV¨R8$ © 1M© @WE.$D* "/.$@ ?.$§h()§ .+ jBS3 ©t=§ c§!=.E6?QÃ,·$´ ·$¶Â,7º$%f§ ©t§ (F%!_E a§ a©tK© a? 3!©#*t`$ [ N.$F./w!© bH6¦¨§! © %cdV=.8* B-5a.E,$ §© !"M[5$EX.$$O!"/G !. !E./() .$ © © .$ ).$5`§ F.E:,$ > !D.$L§! ().$Q§ $FWVU©#Eh K*#"$h.K ( * *=n¨§½^9A¿/½ ©[¿$¶ 9<;·µ¶ 9Nx:H "/./()R>. §R © E Q?© "X().+!*#iH¦¨§ 3 *t© dL§ © B%6V¨F5C.E3 X./J§!.BV .1"/!,81() § 3 +? $*#$!EB[.E/H%$K:_B%§ ÷/´ ·¶Â,7 N FE3! © 2f*tR §-Q3! K§ * B5=.E,$ ©tE*tRw$ K* () %VU§ © E,§ !E./() .$ c$* *f§!`n<?!©#"fx&.E,+ &§j2+©#.$*#=§!¨yB@A.@u V¨QVU© * *&:5a.D K0¿BÂ9<;77 )7 H E.$ N,$© `3 © *j .©#* * "/$*cE.$!©t© ./! K_© NBH6¬© $* *tR%© `.E=() §EBh?]E./! N3 EB?$*# EB3 © !" § D9<;N·$¶ &¿; N &% () §!@A E© ­ EQ© !5C.$( © .$> 3 E,§>$ ©t§ :]© @WE.$6.$]./3@[email protected]()§ .+ HcaD© !@AE.$U* "/.$@ § * ()@A .+!*#© ./! § © O8§!D .+ '&E..$,© @ - ma!:©#2/B5./( § 6? $*#$!EB.E/%+$ N.$ © FdV=.G!,?$ %g./ 5C.$K§!() §F* () %$[§! Application .$§!U5.a§!() §X .+! H Etree API n g e o r application-specific input n l i e i t r a o a c t t element a e c n d u g n o i a i database a l A v L L u a a q b n construct unbalanced balance balanced transform octree octree etreelibrary etreelibrary etreelibrary B-Tree node database Etree library Figure 2: Etree method of generating octree meshes. Figure 3: Etree architecture. ¨=./!E 3$* *tR%f 3!E:§` .E mEB$h?6©#() !* ()BQVU©t§ 3! ©#S3 )bfR8EBO? [,/©t©#.$*6 -,$? NR! N(FH> 4.1 The etree API $ © "$ BG.hB$E,§X.E,$6§-U E.+! ¨§!K* .EB© .$>$ ¦¨§ G ( $* *aKk'h.5K§!GF* ©#?,R4© ) § .BVUL© J¬© "$@ © §>.$5$°.E:,$BH ¦¨§ L§ F.E:,$ )EB$°?[B 3!ho!HD¦¨§ )`kma© ©#! ©tBw?Rw©K ©t_>­ *#h$I $wEB $ G;7¿$;º F$ 0 N.$B4© O9A·fô#7G§ DE.$ .$! h. ?EB-"/.©#§BF© +.h§!QE* H ¢ § a.E$H © EU§ U N3!E3!,*©#5.( © ./ © ¨* /R !E.+!B>© >§ bfR>2$$* 3!/%§ © +:$*j.E,$ %gVU§ © E,§ 2fw5.>§ wB2+© "f-©#.$ !3! ./ $%KEB±?8./ © ./* * R d!© ©#*#© §B-© ./ $ E*#$+3 ¦ ` ¦E$? _E* 3Bh5./( § ¨,? * /HmIK ,-© ./ m./D§!6.EUEB ./ !B-EB-B$JE*#.$ B $ [©t5©tGV=0s.$@ ¡£¢¥¤ ?,$! *-BF.
Load more

Recommended publications
  • Finding Neighbors in a Forest: a B-Tree for Smoothed Particle Hydrodynamics Simulations
    Finding Neighbors in a Forest: A b-tree for Smoothed Particle Hydrodynamics Simulations Aurélien Cavelan University of Basel, Switzerland [email protected] Rubén M. Cabezón University of Basel, Switzerland [email protected] Jonas H. M. Korndorfer University of Basel, Switzerland [email protected] Florina M. Ciorba University of Basel, Switzerland fl[email protected] May 19, 2020 Abstract Finding the exact close neighbors of each fluid element in mesh-free computational hydrodynamical methods, such as the Smoothed Particle Hydrodynamics (SPH), often becomes a main bottleneck for scaling their performance beyond a few million fluid elements per computing node. Tree structures are particularly suitable for SPH simulation codes, which rely on finding the exact close neighbors of each fluid element (or SPH particle). In this work we present a novel tree structure, named b-tree, which features an adaptive branching factor to reduce the depth of the neighbor search. Depending on the particle spatial distribution, finding neighbors using b-tree has an asymptotic best case complexity of O(n), as opposed to O(n log n) for other classical tree structures such as octrees and quadtrees. We also present the proposed tree structure as well as the algorithms to build it and to find the exact close neighbors of all particles. arXiv:1910.02639v2 [cs.DC] 18 May 2020 We assess the scalability of the proposed tree-based algorithms through an extensive set of performance experiments in a shared-memory system. Results show that b-tree is up to 12× faster for building the tree and up to 1:6× faster for finding the exact neighbors of all particles when compared to its octree form.
    [Show full text]
  • Skip-Webs: Efficient Distributed Data Structures for Multi-Dimensional Data Sets
    Skip-Webs: Efficient Distributed Data Structures for Multi-Dimensional Data Sets Lars Arge David Eppstein Michael T. Goodrich Dept. of Computer Science Dept. of Computer Science Dept. of Computer Science University of Aarhus University of California University of California IT-Parken, Aabogade 34 Computer Science Bldg., 444 Computer Science Bldg., 444 DK-8200 Aarhus N, Denmark Irvine, CA 92697-3425, USA Irvine, CA 92697-3425, USA large(at)daimi.au.dk eppstein(at)ics.uci.edu goodrich(at)acm.org ABSTRACT name), a prefix match for a key string, a nearest-neighbor We present a framework for designing efficient distributed match for a numerical attribute, a range query over various data structures for multi-dimensional data. Our structures, numerical attributes, or a point-location query in a geomet- which we call skip-webs, extend and improve previous ran- ric map of attributes. That is, we would like the peer-to-peer domized distributed data structures, including skipnets and network to support a rich set of possible data types that al- skip graphs. Our framework applies to a general class of data low for multiple kinds of queries, including set membership, querying scenarios, which include linear (one-dimensional) 1-dim. nearest neighbor queries, range queries, string prefix data, such as sorted sets, as well as multi-dimensional data, queries, and point-location queries. such as d-dimensional octrees and digital tries of character The motivation for such queries include DNA databases, strings defined over a fixed alphabet. We show how to per- location-based services, and approximate searches for file form a query over such a set of n items spread among n names or data titles.
    [Show full text]
  • Octree Generating Networks: Efficient Convolutional Architectures for High-Resolution 3D Outputs
    Octree Generating Networks: Efficient Convolutional Architectures for High-resolution 3D Outputs Maxim Tatarchenko1 Alexey Dosovitskiy1,2 Thomas Brox1 [email protected] [email protected] [email protected] 1University of Freiburg 2Intel Labs Abstract Octree Octree Octree dense level 1 level 2 level 3 We present a deep convolutional decoder architecture that can generate volumetric 3D outputs in a compute- and memory-efficient manner by using an octree representation. The network learns to predict both the structure of the oc- tree, and the occupancy values of individual cells. This makes it a particularly valuable technique for generating 323 643 1283 3D shapes. In contrast to standard decoders acting on reg- ular voxel grids, the architecture does not have cubic com- Figure 1. The proposed OGN represents its volumetric output as an octree. Initially estimated rough low-resolution structure is gradu- plexity. This allows representing much higher resolution ally refined to a desired high resolution. At each level only a sparse outputs with a limited memory budget. We demonstrate this set of spatial locations is predicted. This representation is signifi- in several application domains, including 3D convolutional cantly more efficient than a dense voxel grid and allows generating autoencoders, generation of objects and whole scenes from volumes as large as 5123 voxels on a modern GPU in a single for- high-level representations, and shape from a single image. ward pass. large cell of an octree, resulting in savings in computation 1. Introduction and memory compared to a fine regular grid. At the same 1 time, fine details are not lost and can still be represented by Up-convolutional decoder architectures have become small cells of the octree.
    [Show full text]
  • Evaluation of Spatial Trees for Simulation of Biological Tissue
    Evaluation of spatial trees for simulation of biological tissue Ilya Dmitrenok∗, Viktor Drobnyy∗, Leonard Johard and Manuel Mazzara Innopolis University Innopolis, Russia ∗ These authors contributed equally to this work. Abstract—Spatial organization is a core challenge for all large computation time. The amount of cells practically simulated on agent-based models with local interactions. In biological tissue a single computer generally stretches between a few thousands models, spatial search and reinsertion are frequently reported to a million, depending on detail level, hardware and simulated as the most expensive steps of the simulation. One of the main methods utilized in order to maintain both favourable algorithmic time range. complexity and accuracy is spatial hierarchies. In this paper, we In center-based models, movement and neighborhood de- seek to clarify to which extent the choice of spatial tree affects tection remains one of the main performance bottlenecks [2]. performance, and also to identify which spatial tree families are Performances in these bottlenecks are deeply intertwined with optimal for such scenarios. We make use of a prototype of the the spatial structure chosen for the simulation. new BioDynaMo tissue simulator for evaluating performances as well as for the implementation of the characteristics of several B. BioDynaMo different trees. The BioDynaMo project [3] is developing a new general I. INTRODUCTION platform for computer simulations of biological tissue dynam- The high pace of neuroscientific research has led to a ics, with a brain development as a primary target. The platform difficult problem in synthesizing the experimental results into should be executable on hybrid cloud computing systems, effective new hypotheses.
    [Show full text]
  • The Peano Software—Parallel, Automaton-Based, Dynamically Adaptive Grid Traversals
    The Peano software|parallel, automaton-based, dynamically adaptive grid traversals Tobias Weinzierl ∗ December 4, 2018 Abstract We discuss the design decisions, design alternatives and rationale behind the third generation of Peano, a framework for dynamically adaptive Cartesian meshes derived from spacetrees. Peano ties the mesh traversal to the mesh storage and supports only one element-wise traversal order resulting from space-filling curves. The user is not free to choose a traversal order herself. The traversal can exploit regular grid subregions and shared memory as well as distributed memory systems with almost no modifications to a serial application code. We formalize the software design by means of two interacting automata|one automaton for the multiscale grid traversal and one for the application- specific algorithmic steps. This yields a callback-based programming paradigm. We further sketch the supported application types and the two data storage schemes real- ized, before we detail high-performance computing aspects and lessons learned. Special emphasis is put on observations regarding the used programming idioms and algorith- mic concepts. This transforms our report from a \one way to implement things" code description into a generic discussion and summary of some alternatives, rationale and design decisions to be made for any tree-based adaptive mesh refinement software. 1 Introduction Dynamically adaptive grids are mortar and catalyst of mesh-based scientific computing and thus important to a large range of scientific and engineering applications. They enable sci- entists and engineers to solve problems with high accuracy as they invest grid entities and computational effort where they pay off most.
    [Show full text]
  • The Skip Quadtree: a Simple Dynamic Data Structure for Multidimensional Data
    The Skip Quadtree: A Simple Dynamic Data Structure for Multidimensional Data David Eppstein† Michael T. Goodrich† Jonathan Z. Sun† Abstract We present a new multi-dimensional data structure, which we call the skip quadtree (for point data in R2) or the skip octree (for point data in Rd , with constant d > 2). Our data structure combines the best features of two well-known data structures, in that it has the well-defined “box”-shaped regions of region quadtrees and the logarithmic-height search and update hierarchical structure of skip lists. Indeed, the bottom level of our structure is exactly a region quadtree (or octree for higher dimensional data). We describe efficient algorithms for inserting and deleting points in a skip quadtree, as well as fast methods for performing point location and approximate range queries. 1 Introduction Data structures for multidimensional point data are of significant interest in the computational geometry, computer graphics, and scientific data visualization literatures. They allow point data to be stored and searched efficiently, for example to perform range queries to report (possibly approximately) the points that are contained in a given query region. We are interested in this paper in data structures for multidimensional point sets that are dynamic, in that they allow for fast point insertion and deletion, as well as efficient, in that they use linear space and allow for fast query times. Related Previous Work. Linear-space multidimensional data structures typically are defined by hierar- chical subdivisions of space, which give rise to tree-based search structures. That is, a hierarchy is defined by associating with each node v in a tree T a region R(v) in Rd such that the children of v are associated with subregions of R(v) defined by some kind of “cutting” action on R(v).
    [Show full text]
  • Hierarchical Bounding Volumes Grids Octrees BSP Trees Hierarchical
    Spatial Data Structures HHiieerraarrcchhiiccaall BBoouunnddiinngg VVoolluummeess GGrriiddss OOccttrreeeess BBSSPP TTrreeeess 11/7/02 Speeding Up Computations • Ray Tracing – Spend a lot of time doing ray object intersection tests • Hidden Surface Removal – painters algorithm – Sorting polygons front to back • Collision between objects – Quickly determine if two objects collide Spatial data-structures n2 computations 3 Speeding Up Computations • Ray Tracing – Spend a lot of time doing ray object intersection tests • Hidden Surface Removal – painters algorithm – Sorting polygons front to back • Collision between objects – Quickly determine if two objects collide Spatial data-structures n2 computations 3 Speeding Up Computations • Ray Tracing – Spend a lot of time doing ray object intersection tests • Hidden Surface Removal – painters algorithm – Sorting polygons front to back • Collision between objects – Quickly determine if two objects collide Spatial data-structures n2 computations 3 Speeding Up Computations • Ray Tracing – Spend a lot of time doing ray object intersection tests • Hidden Surface Removal – painters algorithm – Sorting polygons front to back • Collision between objects – Quickly determine if two objects collide Spatial data-structures n2 computations 3 Speeding Up Computations • Ray Tracing – Spend a lot of time doing ray object intersection tests • Hidden Surface Removal – painters algorithm – Sorting polygons front to back • Collision between objects – Quickly determine if two objects collide Spatial data-structures n2 computations 3 Spatial Data Structures • We’ll look at – Hierarchical bounding volumes – Grids – Octrees – K-d trees and BSP trees • Good data structures can give speed up ray tracing by 10x or 100x 4 Bounding Volumes • Wrap things that are hard to check for intersection in things that are easy to check – Example: wrap a complicated polygonal mesh in a box – Ray can’t hit the real object unless it hits the box – Adds some overhead, but generally pays for itself.
    [Show full text]
  • Spatial Partitioning and Functional Shape Matched Deformation
    SPATIAL PARTITIONING AND FUNCTIONAL SHAPE MATCHED DEFORMATION ALGORITHM FOR INTERACTIVE HAPTIC MODELING A dissertation presented to the faculty of the Russ College of Engineering and Technology of Ohio University In partial fulfillment of the requirements for the degree Doctor of Philosophy Wei Ji November 2008 © 2008 Wei Ji. All Rights Reserved. 2 This dissertation titled SPATIAL PARTITIONING AND FUNCTIONAL SHAPE MATCHED DEFORMATION ALGORITHM FOR INTERACTIVE HAPTIC MODELING by WEI JI has been approved for the School of Electrical Engineering and Computer Science and the Russ College of Engineering and Technology by Robert L. Williams II Professor of Mechanical Engineering Dennis Irwin Dean, Russ College of Engineering and Technology 3 Abstract JI, WEI, Ph.D., November 2008, Computer Science SPATIAL PARTITIONING AND FUNCTIONAL SHAPE MATCHED DEFORMATION ALGORITHM FOR INTERACTIVE HAPTIC MODELING (161 pp.) Director of Dissertation: Robert L. Williams II This dissertation focuses on the fast rendering algorithms on real-time 3D modeling. To improve the computational efficiency, binary space partitioning (BSP) and octree are implemented on the haptic model. Their features are addressed in detail. Three methods of triangle assignment with the splitting plane are discussed. The solutions for optimizing collision detection (CD) are presented and compared. The complexities of these partition methods are discussed, and recommendation is made. Then the deformable haptic model is presented. In this research, for the haptic modeling, the deformation calculation is only related to the graphics process because the haptic rendering is invisible and non-deformable rendering saves much computation cost. To achieve the fast deformation computation in the interactive simulation, the functional shape matched deformation (FSMD) algorithm is proposed for the tangential and normal components of the surface deformation.
    [Show full text]
  • High Quality Interactive Rendering of Massive Point Models Using Multi-Way Kd-Trees
    High Quality Interactive Rendering of Massive Point Models using Multi-way kd-Trees Prashant Goswami Yanci Zhang Renato Pajarola Enrico Gobbetti University of Zurich Sichuan University University of Zurich CRS4 Switzerland China Switzerland Italy goswami@ifi.uzh.ch [email protected] [email protected] [email protected] Abstract—We present a simple and efficient technique for sized nodes. Since all blocks are equal sized, on-board out-of-core multiresolution construction and high quality visu- memory management is particularly simple and effective. alization of large point datasets. The method introduces a novel The presented approach results in fast pre-processing and hierarchical LOD data organization based on multi-way kd-trees that simplifies memory management and allows controlling the high quality rendering of massive point clouds at hundreds LOD tree’s height. The technique is incorporated in a full end- of millions of splats/second on modern GPUs, improving to-end system, which is evaluated on complex models made of the quality vs. performance ratio compared to previous large hundreds of millions of points. point data rendering methods. Keywords-point based rendering; gpu-based; multi-way kd- tree; II. RELATED WORK While the use of points as rendering primitives has been I. INTRODUCTION introduced as early as in [1], [2], only over the last decade they have reached the significance of fully established ge- Modern 3D scanning systems can generate massive data ometry and graphics primitives, see also [3]–[5]. Several sets with hundreds of millions of points. Despite the ad- techniques have since been proposed for improving upon vances in point-based modeling and rendering, these models the display quality, LOD rendering, as well as for efficient can still be a challenge to be processed and in particular out-of-core rendering of large point models.
    [Show full text]
  • Statistical Optimization of Octree Searches
    Statistical optimization of octree searches RENER CASTRO,THOMAS LEWINER,HELIO´ LOPES,GEOVAN TAVARES AND ALEX BORDIGNON Department of Mathematics — Pontif´ıcia Universidade Catolica´ — Rio de Janeiro — Brazil frener, tomlew, lopes, tavares, [email protected]. Abstract. This work emerged from the following observation: usual search procedures for octrees start from the root to retrieve the data stored at the leaves. But since the leaves are the farthest nodes to the root, why start from the root? With usual octree representations, there is no other way to access a leaf. However, hashed octrees allow direct access to any node, given its position in space and its depth in the octree. Search procedures take the position as an input, but the depth remains unknown. This work proposes to estimate the depth of an arbitrary node through a statistical optimization of the average cost of search procedures. Since the highest costs of these algorithms are obtained when starting from the root, this method improves on both the memory footprint by the use of hashed octrees, and execution time through the proposed optimization. Keywords: Octree. Hashing. Quadtree. Geometric Modelling. Data Structures. top down x 104 bottom up 8 statistical 6 1 8 18 4 # leaves Search time 2 0 12 3 4 5 6 7 8 9 10 level Figure 1: Since the leaves are the farthest nodes to the root, why start from the root to look for the leaves? An optimal initial level greatly reduces the search costs: (left) an octree refined to separate each vertex of the Stanford bunny; (middle) the histogram of the number of octree leaves per depth; (right) cost of searching for a leaf starting from different depths.
    [Show full text]
  • Comparison of Nearest-Neighbor-Search Strategies and Implementations for Efficient Shape Registration
    Journal of Software Engineering for Robotics 3(1), March 2012, 2-12 ISSN: 2035-3928 Comparison of nearest-neighbor-search strategies and implementations for efficient shape registration Jan Elseberg1,∗ Stephane´ Magnenat2 Roland Siegwart2 Andreas Nuchter¨ 1 1 Automation Group, Jacobs University Bremen gGmbH, 28759 Bremen, Germany 2 Autonomous Systems Lab, ETH Zurich,¨ Switzerland ∗[email protected] Abstract—The iterative closest point (ICP) algorithm is one of the most popular approaches to shape registration currently in use. At the core of ICP is the computationally-intensive determination of nearest neighbors (NN). As of now there has been no comprehensive analysis of competing search strategies for NN. This paper compares several libraries for nearest-neighbor search (NNS) on both simulated and real data with a focus on shape registration. In addition, we present a novel efficient implementation of NNS via k-d trees as well as a novel algorithm for NNS in octrees. Index Terms—shape registration, nearest neighbor search, k-d tree, octree, data structures 1 INTRODUCTION point can be avoided by employing spatial data structures. The average runtime of NNS is then usually in the order Shape registration is the problem of finding the rigid trans- of O(n log m) but is still by far the most computationally formation that, given two shapes, transforms one onto the expensive part of shape registration. This paper gives a other. The given shapes do not need to be wholly identical. comprehensive empirical analysis of NNS algorithms in the As long as a partial overlap is possible, shape registration domain of 3-dimensional shape matching.
    [Show full text]
  • Quadtree Generating Networks: Efficient Hierarchical Scene Parsing with Sparse Convolutions
    Quadtree Generating Networks: Efficient Hierarchical Scene Parsing with Sparse Convolutions Kashyap Chitta1∗ Jose M. Alvarez2 Martial Hebert3 1 Autonomous Vision Group, MPI for Intelligent Systems and University of Tubingen¨ 2 NVIDIA 3 The Robotics Institute, Carnegie Mellon University [email protected] [email protected] [email protected] Abstract Semantic segmentation with Convolutional Neural Net- works is a memory-intensive task due to the high spatial resolution of feature maps and output predictions. In this paper, we present Quadtree Generating Networks (QGNs), a novel approach able to drastically reduce the memory footprint of modern semantic segmentation networks. The key idea is to use quadtrees to represent the predictions and target segmentation masks instead of dense pixel grids. Our quadtree representation enables hierarchical process- ing of an input image, with the most computationally de- manding layers only being used at regions in the image containing boundaries between classes. In addition, given a trained model, our representation enables flexible infer- ence schemes to trade-off accuracy and computational cost, Figure 1. Efficient quadtree representation of a segmentation mask allowing the network to adapt in constrained situations with three semantic classes (green, blue and yellow). Each node in such as embedded devices. We demonstrate the benefits of the tree has four children, which represent quadrants of the corre- our approach on the Cityscapes, SUN-RGBD and ADE20k sponding image region in a clockwise order.
    [Show full text]