“Remember Me, Will You?”: Overusing Material Gifts for Interpersonal Memory Management

2021 ◽  
Author(s):  
Adelle X. Yang ◽  
Minjung Koo ◽  
Jaewon Hwang
Keyword(s):  
Memory Management

Simple, fast, and safe manual memory management

2017 ◽  
Vol 52 (6) ◽  
pp. 233-247
Author(s):  
Piyus Kedia ◽  
Manuel Costa ◽  
Matthew Parkinson ◽  
Kapil Vaswani ◽  
Dimitrios Vytiniotis ◽  
...  
Keyword(s):  
Memory Management

Supporting ada memory management in the iAPX-432

1982 ◽  
Vol 10 (2) ◽  
pp. 117-131 ◽  
Author(s):  
Fred J. Pollack ◽  
George W. Cox ◽  
Dan W. Hammerstrom ◽  
Kevin C. Kahn ◽  
Konrad K. Lai ◽  
...  
Keyword(s):  
Memory Management

Compartmental memory management in a modern web browser

2011 ◽  
Vol 46 (11) ◽  
pp. 119-128 ◽  
Author(s):  
Gregor Wagner ◽  
Andreas Gal ◽  
Christian Wimmer ◽  
Brendan Eich ◽  
Michael Franz
Keyword(s):  
Memory Management ◽  
Web Browser

scholarly journals Real-time FPGA-based implementation of the AKAZE algorithm with nonlinear scale space generation using image partitioning

2021 ◽  
Author(s):  
Parastoo Soleimani ◽  
David W. Capson ◽  
Kin Fun Li
Keyword(s):  
Real Time ◽  
Memory Management ◽  
Scale Space ◽  
Image Resolution ◽  
Hardware Architecture ◽  
Frame Rate ◽  
Time Sharing ◽  
Scale Invariant ◽  
Nonlinear Scale Space ◽  
Nonlinear Scale

AbstractThe first step in a scale invariant image matching system is scale space generation. Nonlinear scale space generation algorithms such as AKAZE, reduce noise and distortion in different scales while retaining the borders and key-points of the image. An FPGA-based hardware architecture for AKAZE nonlinear scale space generation is proposed to speed up this algorithm for real-time applications. The three contributions of this work are (1) mapping the two passes of the AKAZE algorithm onto a hardware architecture that realizes parallel processing of multiple sections, (2) multi-scale line buffers which can be used for different scales, and (3) a time-sharing mechanism in the memory management unit to process multiple sections of the image in parallel. We propose a time-sharing mechanism for memory management to prevent artifacts as a result of separating the process of image partitioning. We also use approximations in the algorithm to make hardware implementation more efficient while maintaining the repeatability of the detection. A frame rate of 304 frames per second for a $$1280 \times 768$$ 1280 × 768 image resolution is achieved which is favorably faster in comparison with other work.

scholarly journals On the Applicability of PEBS based Online Memory Access Tracking for Heterogeneous Memory Management at Scale

2018 ◽  
Author(s):  
Aleix Roca Nonell ◽  
Balazs Gerofi ◽  
Leonardo Bautista-Gomez ◽  
Dominique Martinet ◽  
Vicenç Beltran Querol ◽  
...  
Keyword(s):  
Memory Management ◽  
Memory Access

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

2021 ◽  
Vol 43 (1) ◽  
pp. 1-73
Author(s):  
David J. Pearce
Keyword(s):  
Memory Management ◽  
Programming Model ◽  
Type System ◽  
Control Flow ◽  
Two Phase ◽  
Type Checking ◽  
Strong Focus ◽  
Reference Implementation ◽  
Two Phases ◽  
Complex Features

Rust is a relatively new programming language that has gained significant traction since its v1.0 release in 2015. Rust aims to be a systems language that competes with C/C++. A claimed advantage of Rust is a strong focus on memory safety without garbage collection. This is primarily achieved through two concepts, namely, reference lifetimes and borrowing . Both of these are well-known ideas stemming from the literature on region-based memory management and linearity / uniqueness . Rust brings both of these ideas together to form a coherent programming model. Furthermore, Rust has a strong focus on stack-allocated data and, like C/C++ but unlike Java, permits references to local variables. Type checking in Rust can be viewed as a two-phase process: First, a traditional type checker operates in a flow-insensitive fashion; second, a borrow checker enforces an ownership invariant using a flow-sensitive analysis. In this article, we present a lightweight formalism that captures these two phases using a flow-sensitive type system that enforces “ type and borrow safety .” In particular, programs that are type and borrow safe will not attempt to dereference dangling pointers. Our calculus core captures many aspects of Rust, including copy- and move-semantics, mutable borrowing, reborrowing, partial moves, and lifetimes. In particular, it remains sufficiently lightweight to be easily digested and understood and, we argue, still captures the salient aspects of reference lifetimes and borrowing. Furthermore, extensions to the core can easily add more complex features (e.g., control-flow, tuples, method invocation). We provide a soundness proof to verify our key claims of the calculus. We also provide a reference implementation in Java with which we have model checked our calculus using over 500B input programs. We have also fuzz tested the Rust compiler using our calculus against 2B programs and, to date, found one confirmed compiler bug and several other possible issues.

Sign in / Sign up

Export Citation Format

Share Document