Spatial data arises in applications such as geographical information systems, computer aided design and computer vision. A practical indexing method for spatial data is the R-tree [1]. A common query to an R-tree is a window query which outputs all spatial objects that intersect a rectangular region in space. The PR-tree is the first R-tree variant where window query performance is asymptotically optimal in the worst case. In this work a PR-tree is updated using algorithms defined by Antonin Guttman [2] and Beckmann et al. [3], respectively and query performance is evaluated. The conclusion is that the R*-tree algorithms by Beckmann et al. [3] is superior to the algorithms by Antonin Guttman [2] for maintaining good query performance while updating a PR-tree / Spatial data är vanligt förekommande i geografiska informationssystem, CAD och datorseende. Ett praktiskt index för spatial data är ett R-träd [1]. En vanlig sökfråga till ett R-träd är en så kallad window query som ges ett rektangulärt område och returnerar alla spatiala objekt som skär detta område. PR-trädet är det första R-trädet med asymptotiskt optimal tidskomplexitet för en window query. I detta arbete används PR-trädet som bas och det modifieras med respektiva algoritmer definerade av Antonin Guttman [2] och Beckmann m. fl. [3] och prestanda för rektangulära sökfrågor utvärderas. Slutsatsen är att om målet är att bibehålla bra prestanda för sökfrågor medan PR-trädet modifieras ska algoritmerna av Beckmann m. fl. [3] föredras.

The Swift programming language recently introduced the actor model alongside Swift concurrency as a first-class citizen. Previously, concurrent programming in Swift required importing modules, e.g., Grand Central Dispatch. Grand Central Dispatch is a concurrency framework, often used for implementing shared memory concurrency in Swift. In contrast to Grand Central Dispatch, the Swift actor provides implicit mutual exclusion via message passing concurrency and the notion of actor isolation. This thesis evaluates the performance of the Swift actor and Swift concurrency in comparison to thread-safe objects with Grand Central Dispatch. The study assembled a benchmark suite to measure the performance over central bottlenecks (Chameneos), large counts of independent objects (Dining Philosophers), long-living concurrent objects (Dining Philosophers) and massively parallel messaging (Big). The results indicate the lack of a catch-all solution to concurrent programming in Swift. In comparison to Grand Central Dispatch, a system of actors tends to require more memory to finish execution. By upper bounding concurrency in actors, memory use is effectively limited at the cost of possibly longer execution times. In particular, the results were gathered on a macOS computer. With unique implementations of threads in different operating systems, further studies are needed to evaluate Swift concurrency and the Swift actor on other systems and hardware. In addition, further studies may evaluate the risk of congestion at large numbers of concurrent actors. / Programmeringsspråket Swift introducerade nyligen actor-modellen med Swift concurrency som en förstklassig medborgare. Samtidig programmering i Swift krävde importmoduler innan dess, t.ex. Grand Central Dispatch. Grand Central Dispatch är ett ramverk för samtidighet och används ofta för att implementera samtidighet med delat minne i Swift. I kontrast till Grand Central Dispatch tillhandahåller Swift actors implicit ömsesidig uteslutning via message passing och actor-isolering. Detta examensarbete utvärderar prestandan av Swift actors och Swift concurrency i jämförelse med trådsäkra objekt via Grand Central Dispatch. Studien sammanställde en benchmark suite för att mäta prestandan över centrala flaskhalsar (Chameneos), stora antal oberoende objekt (Dining Philosophers), samtidiga objekt med långa liv (Dining Philosophers) och massivt parallella meddelanden (Big). Resultaten indikerar en avsaknad av en fullständig lösning för samtidig programmering i Swift. I jämförelse med Grand Central Dispatch tenderar ett system av Swift actors att använda mer minne för att slutföra exekvering. Med en övre gräns för samtidighet hos actors begränsas minnesanvändningen effektivt med eventuellt längre exekveringstider. Denna studie samlade resultat med en macOS-dator. Med unika implementeringar av trådar i olika operativsystem behövs ytterligare studier för att utvärdera Swift concurrency och Swift actors på andra system och hårdvaror. Dessutom kan ytterligare studier utvärdera risken av trängsel vid stora antal samtidiga actors.

Today's mobile development resides in the two main operating systems Android and iOS. It is popular to develop mobile applications individually for each respective platform, referred to as native development. To reduce additional costs, cross-platform solutions have emerged that enable shared development for both platforms. Kotlin Multiplatform Mobile (KMM) is a relatively unexplored cross-platform tool developed by JetBrains. The purpose of this study is to evaluate the performance of iOS applications developed in KMM compared to native Swift. We compare the two approaches for developing iOS apps by compiling a benchmark suite and measuring the performance metrics execution time, memory consumption, and CPU usage. Our benchmark suite is a collection of 7 benchmarks consisting of high-level functionalities networking and database management, as well as low-level computational tasks from the Computer Language Benchmarks Game (CLBG) suite. For the studied benchmarks, the results indicate that KMM generally achieves faster execution times, as higher memory consumption and CPU usage. but with a trade-off overhead in higher memory consumption and CPU usage. We have found KMM to achieve up to 2,7 seconds faster execution time, consume up to 390MB more memory, and up to 30% more CPU than with native Swift. libraries achieve faster execution times, but with a trade-off overhead in increased memory consumption and CPU usage. Besides, our results highlight correlations between the garbage collection cycles of KMM with profiling patterns of memory consumption and CPU usage. the specific benchmark implementations analyzed, and the device used to benchmark them. studies are therefore needed to further generalize our conclusions. / Den nutida mobilutvecklingen domineras av de två huvudsakliga operativsystemen Android och iOS. Det är populärt att utveckla mobilapplikationer separat för varje plattform, så kallad native utveckling. För att minska kostnader relaterade till native utveckling har plattformsoberoende lösningar tillkommit, som istället möjliggör delad utveckling för båda plattformarna. Kotlin Multiplatform Mobile (KMM) är ett relativt outforskat plattformsoberoende verktyg utvecklat av JetBrains. Syftet med denna studie är att utvärdera prestandan hos iOS-applikationer utvecklade i KMM jämfört med native Swift. Vi jämför de två tillvägagångssätten för att utveckla iOS-appar genom att sammanställa en benchmark-svit och mäta prestandametrikerna exekveringstid, minnesanvändning och CPU-användning. Vår benchmark svit består av 7 benchmark-program som omfattar högnivåfunktionaliteter som nätverk- och databashantering, samt lågnivåfunktionaliteter med benchmark-algoritmer från Computer Language Benchmarks Game (CLBG)-sviten. För att exekvera benchmark-programmen och samla in prestandametriker har en applikation utvecklats och använts för att utföra våra experiment på en iOS-enhet. För de undersökta benchmark-programmen visar resultaten att KMM generellt uppnår snabbare exekveringstider, men med en kompromiss i form av ökad minnesanvändning och CPU-användning. Vi har observerat att KMM kan uppnå upp till 2,7 sekunder snabbare exekveringstid, förbruka upp till 390MB mer minne och upp till 30% mer CPU-användning jämfört med native Swift. Dessutom antyder våra resultat korrelationer mellan KMM Garbage Collection cykler och profileringsbeteendet i dess minnes- och CPU-användning.