Static Memory Management within Bytecode Languages on Multicore ...

Bytecode systems Static memory References

Static Memory Management within Bytecode Languages on Multicore Systems Simone Campanoni and Luca Rocchini

March 6th 2011

Simone Campanoni and Luca Rocchini

Static Memory Management


Summary

1

Bytecode systems

2

Execution models

3

Static memories

4

References




Acknowledgments Harvard University Prof. David Brooks

Microsoft Research Dr. Aaron Smith

Prof. Gu-Yeon Wei Glenn Holloway Vijay Janapa Reddi Politecnico di Milano Prof. Stefano Crespi Reghizzi Michele Tartara

HiPEAC Prof. Albert Cohen Dr. Erven Rohou Ing. David Yuste

Ettore Speziale Prof. Marco Santambrogio Simone Campanoni and Luca Rocchini



Virtual Machine: State of the art Dynamic Look-Ahead compilation Pipeline

Classic compilation approach





Classic compilation approach





Bytecode schemas





Bytecode schemas





Bytecode schemas





Bytecode schemas





Bytecode systems: main characteristics






Famous examples: Java, C# (.Net), Python, etc. . .






Famous examples: Java, C# (.Net), Python, etc. . . Compact representation per single programs






Famous examples: Java, C# (.Net), Python, etc. . . Compact representation per single programs Language






Famous examples: Java, C# (.Net), Python, etc. . . Compact representation per single programs Language Stack-based






Famous examples: Java, C# (.Net), Python, etc. . . Compact representation per single programs Language Stack-based Platform independent






Famous examples: Java, C# (.Net), Python, etc. . . Compact representation per single programs Language Stack-based Platform independent One byte to encode instruction type







Execution relies on a VM (usually)







Execution relies on a VM (usually) Compilation performed at runtime or at installation-time








Translation unit: method








Translation unit: method Static memories initialized by VM through special methods








Translation unit: method Static memories initialized by VM through special methods





Virtual machine: State of the art Just-In-Time compiler Compile the Bytecode just before executing it





Virtual machine: State of the art Just-In-Time compiler Compile the Bytecode just before executing it Approach Consider application code in Translation Units, i.e., TUs





Virtual machine: State of the art Just-In-Time compiler Compile the Bytecode just before executing it Approach Consider application code in Translation Units, i.e., TUs e.g. method, region






Compile and execute the first TU






Compile and execute the first TU If the execution goes outside compiled TUs, redirect to the JIT compiler to compile and execute the requested one





Virtual machine: State of the art Problems





Virtual machine: State of the art Problems Startup time





Virtual machine: State of the art Problems Startup time Generated code is not optimal





Virtual machine: State of the art Problems Startup time Generated code is not optimal Dynamic Look-Ahead compilation





Virtual machine: State of the art Problems Startup time Generated code is not optimal Dynamic Look-Ahead compilation Recently introduced





Virtual machine: State of the art Problems Startup time Generated code is not optimal Dynamic Look-Ahead compilation Recently introduced Target: multicores





JIT vs. DLA

Static Call Graph





JIT vs. DLA JIT compilation

Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph





JIT vs. DLA DLA compilation

Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph






Static Call Graph





JIT vs. DLA

Static Call Graph


Easy program ⇒ easy parallelization




JIT vs. DLA

Static Call Graph

Easy program ⇒ easy parallelization What about this SCG?





JIT vs. DLA

Static Call Graph

Easy program ⇒ easy parallelization and this SCG?





Dynamic Look-Ahead approach Target Avoid execution stalls due to compilation





Dynamic Look-Ahead approach Target Avoid execution stalls due to compilation Produce optimized code before its execution





Dynamic Look-Ahead approach Target Avoid execution stalls due to compilation Produce optimized code before its execution Approach Compile methods in parallel to minimize the probability of stalling the execution The DLA compiler looks ahead within the call graph (dynamically computed) to compile ahead of time methods No knowledge a priori of the program





Runtime behavior





Runtime behavior

Following the executing method





Runtime behavior






Runtime behavior






Runtime behavior






Runtime behavior






Runtime behavior






Runtime behavior






Runtime behavior



Exploit available resources




Runtime behavior







Runtime behavior







Runtime behavior







Execution Model





Execution Model

Pipeline model





Execution Model

Pipeline model Static memory initialization ∈ compilation





Execution Model

Pipeline model Static memory initialization ∈ compilation For every method m there is M such that ∀m0 ∈ M, m0 m ∧ m0 executed once





Execution Model

Pipeline model Static memory initialization ∈ compilation For every method m there is M such that ∀m0 ∈ M, m0 m ∧ m0 executed once The compiler/VM is in charge to satisfy it





Execution Model

Pipeline model Static memory initialization ∈ compilation For every method m there is M such that ∀m0 ∈ M, m0 m ∧ m0 executed once The compiler/VM is in charge to satisfy it No explicit call ∈ code





Execution Model

Pipeline model Static memory initialization ∈ compilation For every method m there is M such that ∀m0 ∈ M, m0 m ∧ m0 executed once The compiler/VM is in charge to satisfy it No explicit call ∈ code

Dependences cycle: the execution is guaranteed to be correct no matter which one is initialized first




Deadlock Static threads Evaluation

Deadlock Example





Deadlock Example t1 is going to execute m1


t2 is going to execute m2




Deadlock Example t1 is going to execute m1 m1 uses s1


t2 is going to execute m2 m2 uses s2




Deadlock Example t1 is going to execute m1 m1 uses s1 Initializers: M1


t2 is going to execute m2 m2 uses s2 Initializers: M2






Initializers: M1

Initializers: M2

M1 uses s2 ⇒ M2 M1








Initializers: M1

Initializers: M2



t1 waits t2

t2 waits t1







Initializers: M1

Initializers: M2



t1 waits t2

t2 waits t1







Initializers: M1

Initializers: M2



t1 waits t2

t2 waits t1

High level solution







Initializers: M1

Initializers: M2



t1 waits t2

t2 waits t1

High level solution Detection Deadlock detection := detect dependence cycles







Initializers: M1

Initializers: M2



t1 waits t2

t2 waits t1

High level solution Detection Deadlock detection := detect dependence cycles if (exist dependence cycle()) break the cycle() Simone Campanoni and Luca Rocchini




Single-threaded compilers





Single-threaded compilers Deadlock detection





Single-threaded compilers Deadlock detection Thread t asks for a method ⇒ t will compile it





Single-threaded compilers Deadlock detection Thread t asks for a method ⇒ t will compile it t needs si , which is initializing by t 0





Single-threaded compilers Deadlock detection Thread t asks for a method ⇒ t will compile it t needs si , which is initializing by t 0 Deadlock := adding (t, t 0 ) to the waiting graph makes a cycle





Single-threaded compilers Deadlock detection Thread t asks for a method ⇒ t will compile it t needs si , which is initializing by t 0 Deadlock := adding (t, t 0 ) to the waiting graph makes a cycle Deadlock avoidance

∈ ECMA-335 Simone Campanoni and Luca Rocchini




Pipeline model: additional issues






Thread t asks for a method m ; t will compile it






Thread t asks for a method m ; t will compile it t 0 that will compile m is not known






Thread t asks for a method m ; t will compile it t 0 that will compile m is not known |Static threads| has to be unbound





Multi-threaded compilers






Threads asking for compilation






Threads asking for compilation Code executor threads






Threads asking for compilation Code executor threads Static threads







New waiting graph W







New waiting graph W (t, m) = t is waiting for m







New waiting graph W (t, m) = t is waiting for m (m, t) = m is compiling by t








Deadlock detection








Deadlock detection Cycle within W








Deadlock detection Cycle within W





Static threads





Static threads |Static threads| has to be unbound





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime |Static threads|↑





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime |Static threads|↑ Overhead ↑





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime |Static threads|↑ Overhead ↑ Debugging cost ↑





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime |Static threads|↑ Overhead ↑ Debugging cost ↑ |static threads|↓





Static threads |Static threads| has to be unbound |Static threads| ≥ Length(static memory dependences) + 1 |Static threads| is adapted at runtime |Static threads|↑ Overhead ↑ Debugging cost ↑ |static threads|↓ Overhead ↑ in case of increasing |Static threads|





Static threads (2)

Release resources





Static threads (2)

Release resources Compilation pipeline is empty





Static threads (2)

Release resources Compilation pipeline is empty ⇒|static threads|= min





Static threads (2)

Release resources Compilation pipeline is empty ⇒|static threads|= min Acquire resources





Static threads (2)

Release resources Compilation pipeline is empty ⇒|static threads|= min Acquire resources |free static threads|= 0





Static threads (2)

Release resources Compilation pipeline is empty ⇒|static threads|= min Acquire resources |free static threads|= 0 ⇒|static threads| ∗ = 2





Framework used: ILDJIT A compilation framework designed from scratch for parallel systems






Design choices






Design choices Translation unit: method






Design choices Translation unit: method Intermediate Representation: IR






Design choices Translation unit: method Intermediate Representation: IR Translation process:






Design choices Translation unit: method Intermediate Representation: IR Translation process: CIL






Design choices Translation unit: method Intermediate Representation: IR Translation process: CIL ⇒ IR






Design choices Translation unit: method Intermediate Representation: IR Translation process: CIL ⇒ IR ⇒ Machine code







Features: Easy extensible







Features: Easy extensible Target: multi-core systems







Features: Easy extensible Target: multi-core systems Includes JIT, DLA, AOT compilers Simone Campanoni and Luca Rocchini




Evaluation





Evaluation: static threads






Fast adapting






Fast adapting Extra threads






Fast adapting Extra threads Resources releasing




Publications Websites

Publications ILDJIT 1

S. Campanoni, G. Agosta, S. Crespi Reghizzi, A. Di Biagio. “A highly flexible, parallel virtual machine: design and experience of ILDJIT”. Software: Practice and Experience. 2010

DLA 1

S. Campanoni, M. Sykora, G. Agosta, S. Crespi Reghizzi. “Dynamic Look Ahead Compilation: a technique to hide JIT compilation latencies in multicore environment”. CC, 2009.

ILDJIT + ALARM 1

V. Janapa Reddi, S. Campanoni, M. Gupta, M. Smith, G. Wei, D. Brooks. “Software-Assisted Hardware Reliability: Abstracting Circuit-level Challenges to the Software Stack”. DAC, 2009.





Websites

ILDJIT http://ildjit.sourceforge.net

ECMA-335 www.ecma-international.org/publications/standards/Ecma335.htm

ALARM http://www.eecs.harvard.edu/alarms/wiki





Thanks for your attention



Static Memory Management within Bytecode Languages on Multicore ...

Static Memory Management within Bytecode Languages on Multicore ...

Suggest Documents

Better Static Memory Management: Improving ... - Semantic Scholar

Memory Model Sensitive Bytecode Verification - NUS Computing

Software Thermal Management of DRAM Memory for Multicore Systems

Memory Requirements of Java Bytecode Verification on ... - CiteSeerX

Coconut Multicore Framework: Static Analysis Assisted Scheduling

OpenCL for programming shared memory multicore CPUs

The Impact of Diverse Memory Architectures on Multicore ... - Codeplay

An Experimental Study on Memory Allocators in Multicore and ...

A Comparative Study on Memory Allocators in Multicore and ...

Software Transactional Memory for Multicore ... - Semantic Scholar

Deterministic Memory Abstraction and Supporting Multicore ... - DROPS

Workload Adaptive Shared Memory Multicore ... - Deming Chen

On Memory Accelerated Signal Processing within Software

Static Analysis of Dalvik Bytecode and Reflection in Android

A Framework for Memory Management and Optimization of Static and ...

A Framework for Memory Management and Optimization of Static and ...

A Framework for Memory Management and Optimization of Static and

Static and Dynamic Semantics of NoSQL Languages

Static and Dynamic Semantics of NoSQL Languages

Lowering STM overhead with Static Analysis - Multicore Algorithmics ...

Cache-aware static scheduling for hard real-time multicore ... - arXiv

Chapter 7 Memory Management Memory Management

Memory Management 55 Memory Management ... - The TAZ

Prosodic Focus Within and Across Languages - ScholarlyCommons