GhostCell: separating permissions from data in Rust

The Rust language offers a promising approach to safe systems programming based on the principle of aliasing XOR mutability : a value may be either aliased or mutable, but not both at the same time. However, to implement pointer-based data structures with internal sharing, such as graphs or doubly-linked lists, we need to be able to mutate aliased state. To support such data structures, Rust provides a number of APIs that offer so-called interior mutability : the ability to mutate data via method calls on a shared reference. Unfortunately, the existing APIs sacrifice flexibility, concurrent access, and/or performance, in exchange for safety. In this paper, we propose a new Rust API called GhostCell which avoids such sacrifices by separating permissions from data : it enables the user to safely synchronize access to a collection of data via a single permission. GhostCell repurposes an old trick from typed functional programming: branded types (as exemplified by Haskell’s ST monad), which combine phantom types and rank-2 polymorphism to simulate a lightweight form of state-dependent types. We have formally proven the soundness of GhostCell by adapting and extending RustBelt, a semantic soundness proof for a representative subset of Rust, mechanized in Coq.

Analysis of MinFinder Algorithm on Large Data Amounts

When dealing with large amounts of data, various sorting algorithms will be tested and searched for which algorithm is the most efficient. Many factors determine the level of performance of the sorting algorithm, such as time and size complexity, stability, accuracy, clarity, effectiveness, and so on. MinFinder is a newly discovered sorting algorithm by finding the smallest value in each iteration while the program is running. In this paper, the MinFinder algorithm will be tested on the structure of data arrays, vectors and linked lists to compare the speed of completion time. Based on the results of experiments on data with n amount of 10 power of3, 10 power of4, and 10 power of5, it can be concluded that the best application of MinFinder is in the array, with the processing time needed 2X faster than other data structures. Vector and Linked Lists have weaknesses when accessing elements at each iteration, which makes them slower than arrays

Parallel Merging and Sorting on Linked List

We study linked list sorting and merging on the PRAM model. In this paper we show that n real numbers can be sorted into a linked list in constant time with n2+e processors or in ) time with n2 processors. We also show that two sorted linked lists of n integers in {0, 1, …, m} can be merged into one sorted linked list in O(log(c)n(loglogm)1/2) time using n/(log(c)n(loglogm)1/2) processors, where c is an arbitrarily large constant.