Per Larsen

Per Larsen

Auto-generated profile, based on publicly available information

Per Larsen

Immunant, Inc

Research Focus & Metrics

Academic Career Length

18Years (2009-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
14 July 2016 in Proceedings on Privacy Enhancing Technologies
Verified
Journal Article
Open access
PDF file
MCMauro Conti
Mauro Conti
SCStephen Crane
Stephen Crane
TFTommaso Frassetto
Tommaso Frassetto
AHAndrei Homescu
Andrei Homescu
GKGeorg Koppen
Georg Koppen
ASAhmad-Reza Sadeghi
Ahmad-Reza Sadeghi

1 September 2012
Verified
Conference Paper
Closed access
PLPer Larsen
Per Larsen
RLRazya Ladelsky
Razya Ladelsky
JLJacob Lidman
Jacob Lidman
SMSally A. McKee
Sally A. McKee
SKSven Karlsson
Sven Karlsson
AZAyal Zaks
Ayal Zaks
The performance of many parallel applications relies not on instruction-level parallelism but on loop-level parallelism. Unfortunately, automatic parallelization of loops is a fragile process, many different obstacles affect or prevent it in practice. To address this predicament we developed an interactive compilation feedback system that guides programmers in iteratively modifying their application source code. This helps leverage the compiler's ability to generate loop-parallel code. We employ our system to modify two sequential benchmarks dealing with image processing and edge detection, resulting in scalable parallelized code that runs up to 8.3 times faster on an eight-core Intel Xeon 5570 system and up to 12.5 times faster on a quad-core IBM POWER6 system. Benchmark performance varies significantly between the systems. This suggests that semi-automatic parallelization should be combined with target-specific optimizations. Furthermore, comparing the first benchmark to manually-parallelized, hand-optimized pthreads and OpenMP versions, we find that code generated using our approach typically outperforms the pthreads code (within 93-339%). It also performs competitively against the OpenMP code (within 75-111%). The second benchmark outperforms manually-parallelized and optimized OpenMP code (within 109-242%).

15 October 2014
Verified
Conference Paper
Open access
ZWZhan Wei
Zhan Wei
PLPer Larsen
Per Larsen
SBStefan Brunthaler
Stefan Brunthaler
MFMichael Franz
Michael Franz
Generators offer an elegant way to express iterators. However, their performance has always been their Achilles heel and has prevented widespread adoption. We present techniques to efficiently implement and optimize generators. We have implemented our optimizations in ZipPy, a modern, light-weight AST interpreter based Python 3 implementation targeting the Java virtual machine. Our implementation builds on a framework that optimizes AST interpreters using just-in-time compilation. In such a system, it is crucial that AST optimizations do not prevent subsequent optimizations. Our system was carefully designed to avoid this problem. We report an average speedup of 3.58x for generator-bound programs. As a result, using generators no longer has downsides and programmers are free to enjoy their upsides.

18 April 2024 in IEEE Security & Privacy
Verified
Journal Article
Closed access
PLPer Larsen
Per Larsen
The path for migrating C to Rust can be partially automated. This article discusses when to choose automation and when to migrate by hand and considers several paths to increase automation so more code can be migrated at constant cost.

30 March 2018 in IEEE Security & Privacy
Verified
Journal Article
Open access
TVTimothy Vidas
Timothy Vidas
PLPer Larsen
Per Larsen
HOHamed Okhravi
Hamed Okhravi
ASAhmad-Reza Sadeghi
Ahmad-Reza Sadeghi
For a large part of the world population, software increasingly touches all aspects of life. Clearly there are societal and business benefits to be gained, but the pervasiveness of software also presents unprecedented risk. The lack of capable people to either analyze existing or safely create new software paired with the sheer volume and accelerating pace of software development lends to automated approaches to address this risk. The Cyber Grand Challenge presented an opportunity to advance the state of the art and science in autonomous reasoning in software security. The culmination of this contest presented seven fully autonomous systems vying against each other hacking and defending previously unseen computer software, ultimately making sense of zero-day attacks, entirely without any human assistance. This collection of works presents many aspects of autonomous software security from differing perspectives. The authors detail solution approaches as well as evidence of the challenges that remain. As with many aspects of computing, while much has been accomplished software security, much work remains.

11 September 2013
Verified
Conference Paper
Open access
GSGülfem Savrun-Yeniçeri
Gülfem Savrun-Yeniçeri
WZWei Zhang
Wei Zhang
HZHuahan Zhang
Huahan Zhang
CLChen Li
Chen Li
SBStefan Brunthaler
Stefan Brunthaler
MFMichael Franz
Michael Franz
The Java virtual machine is a popular target for many language implementers. Due to the unusually poor performance of hosted interpreters, many programming language implementers resort to implementing a custom compiler that emits Java bytecode instead. We studied performance of these hosted interpreters targeting the JVM and identified common bottlenecks preventing their efficient execution. First, similar to interpreters written in C/C++, instruction dispatch is expensive on the JVM. Second, Java's array semantics dictate expensive runtime exception checks, which negatively affect array performance essential to interpreters. We present two optimizations targeting these bottlenecks and show that the performance of the optimized interpreters increases dramatically: we report speedups by a factor of up to 2.45 over the Jython interpreter, and 3.57 over the Rhino interpreter respectively. Furthermore, the performance attained through our optimizations is comparable with custom compiler performance. We provide an easily accessible annotation-based interface to enable our optimizations. Thus, interpreter implementers can expect substantial performance boosts in a matter of hours of implementation effort.