Simple, safe, and efficient memory management using linear pointers

Efficient and safe memory management is a hard problem. Garbage collection promises automatic memory management but comes with the cost of increased memory footprint, reduced parallelism in multi-threaded programs, unpredictable pause time, and intricate tuning parameters balancing the program's workload and designated memory usage in order for an application to perform reasonably well. Existing research mitigates the above problems to some extent, but programmer error could still cause memory leak by erroneously keeping memory references when they are no longer needed. We need a methodology for programmers to become resource aware, so that efficient, scalable, predictable and high performance programs may be written without the fear of resource leak. Linear logic has been recognized as the formalism of choice for resource tracking. It requires explicit introduction and elimination of resources and guarantees that a resource cannot be implicitly shared or abandoned, hence must be linear. Early languages based on linear logic focused on Curry-Howard correspondence. They began by limiting the expressive powers of the language and then reintroduced them by allowing controlled sharing which is necessary for recursive functions. However, only by deviating from Curry-Howard correspondence could later development actually address programming errors in resource usage. The contribution of this dissertation is a simple, safe, and efficient approach introducing linear resource ownership semantics into C++ (which is still a widely used language after 30 years since inception) through linear pointer, a smart pointer inspired by linear logic. By implementing various linear data structures and a parallel, multi-threaded memory allocator based on these data structures, this work shows that linear pointer is practical and efficient in the real world, and that it is possible to build a memory management stack that is entirely leak free. The dissertation offers some closing remarks on the difficulties a formal system would encounter when reasoning about a concurrent linear data algorithm, and what might be done to solve these problems

Asynchronous techniques for new generation variation-tolerant FPGA

PhD ThesisThis thesis presents a practical scenario for asynchronous logic implementation that would benefit the modern Field-Programmable Gate Arrays (FPGAs) technology in improving reliability. A method based on Asynchronously-Assisted Logic (AAL) blocks is proposed here in order to provide the right degree of variation tolerance, preserve as much of the traditional FPGAs structure as possible, and make use of asynchrony only when necessary or beneficial for functionality. The newly proposed AAL introduces extra underlying hard-blocks that support asynchronous interaction only when needed and at minimum overhead. This has the potential to avoid the obstacles to the progress of asynchronous designs, particularly in terms of area and power overheads. The proposed approach provides a solution that is complementary to existing variation tolerance techniques such as the late-binding technique, but improves the reliability of the system as well as reducing the design’s margin headroom when implemented on programmable logic devices (PLDs) or FPGAs. The proposed method suggests the deployment of configurable AAL blocks to reinforce only the variation-critical paths (VCPs) with the help of variation maps, rather than re-mapping and re-routing. The layout level results for this method's worst case increase in the CLB’s overall size only of 6.3%. The proposed strategy retains the structure of the global interconnect resources that occupy the lion’s share of the modern FPGA’s soft fabric, and yet permits the dual-rail iv completion-detection (DR-CD) protocol without the need to globally double the interconnect resources. Simulation results of global and interconnect voltage variations demonstrate the robustness of the method

Applying Behavior Driven Development Practices and Tools to Low-Code Technology

One of the main reasons software projects fail is the lack of communication between stakeholders. Low Code Platforms have been recently growing in the software development market. These allow creating state-of-the-art applications with facilitated design and integration, in a rapid development fashion and as such, avoiding communication errors among stakeholders is indispensable to avoid regressions. Behavior-Driven Development (BDD) is a practice that focuses on developing value-based software, promoting communication by bringing business people into development. The BDDFramework is an open-source testing automation framework within the Out- Systems environment. It allows describing test scenarios using the Gherkin syntax but it is not focused on enabling the BDD process. Our main challenge is: - How can we apply the BDD process in Low Code and support it from a technological point of view, considering the particularities of Low Code environments and having as case study the OutSystems platform? Is the BDDFramework prepared for this? We interviewed some people in the domain to understand their development and testing challenges and their experience with the BDDFramework. With the information gathered and after studying other existing BDD process supporting tools for other languages, we built a prototype that uses the existing BDDFramework and automates it, allowing scenarios to be described in text files, which helps the introduction of business people in the process. The prototype generates all the test structure automatically, reusing equal steps while detecting parameters in the Gherkin descriptions. We performed some real user testing to validate our prototype and we found that our solution was faster, easier, with better usability and we obtained more correct tests than with the previous approach - the BDDFramework alone. Testing in Low Code is still an area with a lot to explore and errors have a huge impact when development is very accelerated, so as communication errors tend to decrease we can start building software even faster and this is what BDD proposes to solve. With this prototype we have been able to demonstrate that it is possible to build a framework that will allow us to enable this process by taking advantage of the OutSystems language particularities to potentiate the BDD practice technologically, while setting a test standard for the OutSystems language