JetBrains Day Seoul - Exploring .NET’s memory management – a trip down memory lane

This document provides an introduction to JProfiler and discusses various techniques for profiling Java applications, including bytecode instrumentation, sampling profiling, and Java Management Extensions (JMX). It describes methods like manually adding print statements, using aspects, creating JMX beans, and using the JVM Tool Interface (JVMTI). The document also covers topics like overhead of profiling, hashcodes, equal methods, and examples of using instrumentation and sampling in profiling tools.

Garbage Collection is an integral part of application behavior on Java platforms, yet it is often misunderstood. As such, it is important for Java developers to understand the actions you can take in selecting and tuning collector mechanisms, as well as in your application architecture choices. Azul Product Manager Matt Schuetze describes the different collectors available and how to choose.

The document discusses Java garbage collection. It explains that garbage collection automatically reclaims memory from objects that are no longer reachable to avoid memory leaks. It describes different garbage collection algorithms and strategies like generational and incremental garbage collection. It also discusses best practices and myths around memory management in Java.

This document provides tips and strategies for optimizing Java application performance through software tuning techniques. It discusses identifying and addressing bottlenecks, avoiding unnecessary object creation, using string pooling and interned strings efficiently, leveraging profilers to analyze performance issues, and optimizing loops and exception handling. The key strategies outlined are to reduce object creation, reuse objects when possible, compare strings effectively, and eliminate unnecessary method calls in loops.

This document provides an overview of Java memory structures and garbage collection. It discusses the key areas of memory used by the JVM - heap, method area, native area, and threads. It then covers garbage collection concepts like roots, algorithms like mark-sweep-compact, and different GC strategies like serial, parallel, concurrent mark-sweep, and Garbage First collector. Performance metrics for evaluating GC and how objects transition between generations in generational collection are also summarized.

This document provides an overview of hacking and computer security concepts such as programming, hacking, vulnerabilities, exploitation, tools, and competitions. It defines key terms like hacking, vulnerability, and exploitation. It recommends programming languages and tools for reversing like Visual Studio, Vim, and Bokken. It also lists computer security competitions and references for learning more. The document aims to introduce someone new to computer security and provide resources to progress their skills.

This document discusses tuning garbage collection in the Java Virtual Machine. It describes key metrics for measuring garbage collection performance like throughput, footprint, and pause times. Factors that impact these metrics like generation sizing, survivor space ratios, and garbage collector selection are explained. The document also provides guidance on using JVM flags and garbage collection logs to analyze and improve performance.

Decades history of kernel exploitation, however still most used techniques are such as ROP. Software based approaches comes finally challenge this technique, one more successful than the others. Those approaches usually trying to solve far more than ROP only problem, and need to handle not only security but almost more importantly performance issues. Another common attacker vector for redirecting control flow is stack what comes from design of today’s architectures, and once again some software approaches lately tackling this as well. Although this software based methods are piece of nice work and effective to big extent, new game changing approach seems coming to the light. Methodology closing this attack vector coming right from hardware - intel. We will compare this way to its software alternatives, how one interleaving another and how they can benefit from each other to challenge attacker by breaking his most fundamental technologies. However same time we go further, to challenge those approaches and show that even with those technologies in place attackers is not yet in the corner.

This session is all about - the mechanism provided by Java Virtual Machine to reclaim heap space from objects which are eligible for Garbage collection.

The Java Memory Model defines rules for how threads interact through shared memory in Java. It specifies rules for atomicity, ordering, and visibility of memory operations. The JMM provides guarantees for code safety while allowing compiler optimizations. It defines a happens-before ordering of instructions. The ordering rules and visibility rules ensure threads see updates from other threads as expected. The JMM implementation inserts memory barriers as needed to maintain the rules on different hardware platforms.

As @nicowaisman mentioned in his talk Aleatory Persistent Threat, old school heap specific exploiting is dying. And with each windows SP or new version, is harder to attack heap itself. Heap management adapt quickly and include new mittigation techniques. But sometimes is better to rethink the idea of mittigation and do this technique properly even half version of it will cover all known heap exploit techniques…

What are some of the performance implications of using lambdas and what strategies can be used to address these. When might be want an alternative to using a lambda and how can we design our APIs to be flexible in this regard. What are the principles of writing low latency code in Java? How do we tune and optimize our code for low latency? When don’t we optimize our code? Where does the JVM help and where does it get in our way? How does this apply to lambdas? How can we design our APIs to use lambdas and minimize garbage?

Slides for the workshop on Parallel Programming in Python I gave on November 10th, 2015 at PyData NYC.

The document discusses Java memory allocation profiling using the Aprof tool. It explains that Aprof works by instrumenting bytecode to inject calls that count and track object allocations. This allows it to provide insights on where memory is being allocated and identify potential performance bottlenecks related to garbage collection.

Profilers find performance bottlenecks in your app but provide confusing information. Let's give you insights into how your profiler and your app are really interacting. What profiling APIs are available, how they work, and what their implementation on the JVM (OpenJDK) side looks like: Stack sampling profilers: stop motion view of your app GetCallTrace(JVisualVM case study): The official stack sampling API Safepoints and safepoint sampling bias AsyncGetCallTrace(Honest Profiler Case Study): The unofficial API JVM Profilers vs System Profilers: No API needed?

The document discusses Java serialization and common myths surrounding it. It summarizes that Java serialization allows for flexible evolution of classes while maintaining backwards compatibility through the use of serialVersionUID. It debunks common myths that Java serialization is slow, inflexible, or that changing private fields breaks compatibility. The document explains that serialization performance depends more on how streams are used rather than the underlying implementation.

This document discusses various overflow issues that can occur with the splice and vmsplice Linux kernel functions. It describes stack and buffer overflows that can happen due to race conditions when accessing pipe buffers. It also proposes a pool overflow technique using SLUB memory and controlled data read from a TTY device to spray the kernel memory and potentially overflow adjacent objects. Finally, it notes that further research is needed to determine a suitable target and exploit methodology, and hints that pipe buffer sizes may allow overflowing kernel memory allocations.

The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated. In this talk, we’ll go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), ClrMD and more!

The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated. In this talk, we’ll go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), ClrMD and more!

Even if your program is just a few lines of code, .NET's runtime will create a number of object in memory. Are all objects being destroyed by the garbage collector? Or is there a potential memory leak? And why is the application seemingly slow when having lots of objects in memory? In this webinar, we'll explore the new dotMemory 4 memory profiler. We'll see why we want to use a memory profiler and how easy it is to use JetBrains dotMemory for that.

These days fast code needs to operate in harmony with its environment. At the deepest level this means working well with hardware: RAM, disks and SSDs. A unifying theme is treating memory access patterns in a uniform and predictable way that is sympathetic to the underlying hardware. For example writing to and reading from RAM and Hard Disks can be significantly sped up by operating sequentially on the device, rather than randomly accessing the data. In this talk we’ll cover why access patterns are important, what kind of speed gain you can get and how you can write simple high level code which works well with these kind of patterns.

This document discusses various low-level performance optimizations related to branch prediction, memory access, storage, and conclusions. It explains that branches can cause stalls, caches help mitigate slow memory access, and sequential access patterns outperform random access. The key themes are optimizing for predictability over randomness and prioritizing principles over specific tools.

For More information, refer to Java EE 7 performance tuning and optimization book: The book is published by Packt Publishing: http://www.packtpub.com/java-ee-7-performance-tuning-and-optimization/book

Linux containers are different from Solaris Zones or BSD Jails: they use discrete kernel features like cgroups, namespaces, SELinux, and more. We will describe those mechanisms in depth, as well as demo how to put them together to produce a container. We will also highlight how different container runtimes compare to each other. This talk was delivered at DockerCon Europe 2015 in Barcelona.