CodeStock - Exploring .NET memory management - a trip down memory lane

This talk answers an age-old question: is garbage collection faster/slower/the same speed as malloc/free? We introduce oracular memory management, an approach that lets us measure unaltered Java programs as if they used malloc and free. The result: a good GC can match the performance of a good allocator, but it takes 5X more space. If physical memory is tight, however, conventional garbage collectors suffer an order-of-magnitude performance penalty.

Accelerated Machine Learning with RAPIDS and MLflow, Nvidia/RAPIDS Abstract: We will introduce RAPIDS, a suite of open source libraries for GPU-accelerated data science, and illustrate how it operates seamlessly with MLflow to enable reproducible training, model storage, and deployment. We will walk through a baseline example that incorporates MLflow locally, with a simple SQLite backend, and briefly introduce how the same workflow can be deployed in the context of GPU enabled Kubernetes clusters.

This document summarizes a presentation by Erin LeDell from H2O.ai about machine learning using the H2O software. H2O is an open-source machine learning platform that provides APIs for R, Python, Scala and other languages. It allows distributed machine learning on large datasets across clusters. The presentation covers H2O's architecture, algorithms like random forests and deep learning, and how to use H2O within R including loading data, training models, and running grid searches. It also discusses H2O on Spark via Sparkling Water and real-world use cases with customers.

1. The document discusses using Deeplearning4j and Kafka together for machine learning workflows. It describes how Deeplearning4j can be used to build, train, and deploy neural networks on JVM and Spark, while Kafka can be used to stream data for training and inference. 2. An example application is described that performs anomaly detection on log files from a CDN by aggregating the data to reduce the number of data points. This allows the model to run efficiently on available GPU hardware. 3. The document provides a link to a GitHub repository with a code example that uses Kafka to stream data, Keras to train a model, and Deeplearning4j to perform inference in Java and deploy the model.

With Anaconda (in particular Numba and Dask) you can scale up your NumPy and Pandas stack to many cpus and GPUs as well as scale-out to run on clusters of machines including Hadoop.

Azul Product Manager Matt Schuetze's presentation on JVM memory details to the Philadelphia Java User Group. This session dovetails with the March, 2014 PhillyJUG deep dive session topic focused on Java compiler code transformation and JVM runtime execution. That session exposes myths that Java is slow and Java uses too much memory. In this session we will take a deeper look at Java memory management. The dreaded Out of Memory (OOM) error is one problem. Garbage collector activity and spikes leading to long pauses is another. He covers the foundations of garbage collection and why historically Java gets a bad rap, even though GC provides a marvelous memory management paradigm.

1) Reynold Xin presented on using sketches like Bloom filters, HyperLogLog, count-min sketches, and stratified sampling to summarize and analyze large datasets in Spark. 2) Sketches allow analyzing data in small space and in one pass to identify frequent items, estimate cardinality, and sample data. 3) Spark incorporates sketches to speed up exploration, feature engineering, and building faster exact algorithms for processing large datasets.

Machine Learning typically involves big datasets and lots of model iterations. This presentation shows how to use GCP to speed up that process with ML Engine and Dataflow. The focus of the presentation is on tooling not on models or business cases.

This document discusses the need for a time series database and introduces OpenTSDB as an option. Some key points: - Time series data is useful for analyzing metrics and patterns over time but is currently scattered across different databases. - OpenTSDB is an open source time series database that can store trillions of data points, scale using HBase, and never loses precision. - It is optimized for write throughput and can handle thousands of data points per second. Reads depend on the cardinality of metrics but it supports time-based queries. - OpenTSDB uses HBase under the hood and stores tags with metrics to allow for flexible filtering of time series data without affecting performance.

In this presentation, we give a brief introduction to Keras and Neural networks, and use examples to explain how to build and train neural network models using this framework. Talk given as part of an event by Rio Machine Learning Meetup.

Sun Tzu said “if you know your enemies and know yourself, you can win a hundred battles without a single loss.” Those words have never been truer than in our time. We are faced with an avalanche of data. Many believe the ability to process and gain insights from a vast array of available data will be the primary competitive advantage for organizations in the years to come. To make sense of data, you will have to face many challenges: how to collect, how to store, how to process, and how to react fast. Although you can build these systems from bottom up, it is a significant problem. There are many technologies, both open source and proprietary, that you can put together to build your analytics solution, which will likely save you effort and provide a better solution. In this session, Srinath will discuss WSO2’s middleware offering in BigData and explain how you can put them together to build a solution that will make sense of your data. The session will cover technologies like thrift for collecting data, Cassandra for storing data, Hadoop for analyzing data in batch mode, and Complex event processing for analyzing data real time.

If you’re subscribed to user@spark.apache.org, or work in a large company, you may see some common Spark error messages. Even attending Spark Summit over the past few years you have seen talks like the “Top K Mistakes in Spark.” While cool non-machine learning based tools do exist to examine Spark’s logs — they don’t use machine learning and therefore are not as cool but also limited in by the amount of effort humans can put into writing rules for them. This talk will look what happens when we train “regular” clustering models on stack traces, and explore DL models for classifying user message to the Spark list. Come for the reassurance that the robots are not yet able to fix themselves, and stay to learn how to work better with the help of our robot friends. The tl;dr of this talk is Spark ML on Spark output, plus a little bit of Tensorflow is fun for the whole family, but probably shouldn’t automatically respond to user list posts just yet.

Chronix is a time series database that can efficiently store billions of time series data points in a small amount of disk space and retrieve data within milliseconds. It works by splitting time series into fixed-size chunks, compressing the chunks, and storing the compressed chunks and associated metadata in Solr/Lucene records. Chronix provides common time series aggregations, transformations, and analyses through its API. The developers tuned Chronix's performance by evaluating different compression techniques and chunk sizes on real-world time series data. Chronix outperformed other time series databases in storage needs and query speeds in their tests.

This document discusses training deep learning models using multiple GPUs in the cloud. It covers the challenges of distributed training including data bottlenecks, communication bottlenecks, and scaling batch sizes and learning rates. It provides benchmarks for frameworks like MXNet and TensorFlow on AWS and discusses the impact of infrastructure like GPU type and interconnect bandwidth on training performance and efficiency. It also analyzes the costs of using different cloud platforms for deep learning training.

Apache TVM is an open source machine learning compiler that distills the largest, most powerful deep learning models into lightweight software that can run on the edge. This allows the outputed model to run inference much faster on a variety of target hardware (CPUs, GPUs, FPGAs & accelerators) and save significant costs. In this deep dive, we’ll discuss how Apache TVM works, share the latest and upcoming features and run a live demo of how to optimize a custom machine learning model.

Large scale data processing analyses and makes sense of large amounts of data. Although the field itself is not new, it is finding many usecases under the theme "Bigdata" where Google itself, IBM Watson, and Google's Driverless car are some of success stories. Spanning many fields, Large scale data processing brings together technologies like Distributed Systems, Machine Learning, Statistics, and Internet of Things together. It is a multi-billion-dollar industry including use cases like targeted advertising, fraud detection, product recommendations, and market surveys. With new technologies like Internet of Things (IoT), these use cases are expanding to scenarios like Smart Cities, Smart health, and Smart Agriculture. Some usecases like Urban Planning can be slow, which is done in batch mode, while others like stock markets need results within Milliseconds, which are done in streaming fashion. There are different technologies for each case: MapReduce for batch processing and Complex Event Processing and Stream Processing for real-time usecases. Furthermore, the type of analysis range from basic statistics like mean to complicated prediction models based on machine Learning. In this talk, we will discuss data processing landscape: concepts, usecases, technologies and open questions while drawing examples from real world scenarios. http://icter.org/conference/invited_speeches

Storm is a framework for reliably processing streaming data. It allows defining topologies composed of spouts (data sources) and bolts (processing components). Spouts emit tuples that are processed by bolts which can emit additional tuples. The document describes a topology for processing tweets in real-time to identify top hashtags and display tweets on a map. It includes spouts to fetch tweets and bolts for filtering, counting hashtags, ranking them and storing results to Redis. Storm provides reliability by tracking processing of tuples through a topology using acknowledgments.

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!

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 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.

The slides for the first ever SnappyData webinar. Covers SnappyData core concepts, programming models, benchmarks and more. SnappyData is open sourced here: https://github.com/SnappyDataInc/snappydata We also have a deep technical paper here: http://www.snappydata.io/snappy-industrial We can be easily contacted on Slack, Gitter and more: http://www.snappydata.io/about#contactus

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

How to approach a problem from a performance standpoint. A small real world application is used as a case study. I\'ve presented "High Performance With Java" at Codebits\'2008 held from 13 to 15 November 2008 (*) Codebits is a programming contest held in Portugal held the spirit of Yahoo Hack! Day

Presentation from DICE Coder's Day (2010 November) by Andreas Fredriksson in the Frostbite team. Goes into detail about Scope Stacks, which are a systems programming tool for memory layout that provides • Deterministic memory map behavior • Single-cycle allocation speed • Regular C++ object life cycle for objects that need it This makes it very suitable for games.

Hibernate provides object relational mapping and allows working with data at the object level rather than directly with SQL. It abstracts the underlying database, handles change detection and caching. The session factory handles connection pooling and caching of mappings. The session represents a unit of work and tracks changes to objects, flushing updates to the database at the end of the session. The first level cache tracks changes to objects within a session. Query caching caches query results to improve performance. The second level cache caches objects beyond a single session.

Improving performance of your .NET code using .NET Core 3.0, Span<T> and more. Presented at Sydney Alt.Net, 30 June 2019

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.

Memory management best practices in Android include using the sparse array family for collections below 1,000 items, avoiding unnecessary object creation, using StringBuilder for string concatenation, properly closing streams to prevent memory leaks, and using patterns like object pools and flyweights to reduce memory usage. The onTrimMemory callback and memory monitoring tools like Memory Monitor and Heap Viewer can help detect memory issues and leaks in an Android application.

Find out more about: • Techniques and tips to optimize trainingon Apache MXNet • Infrastructure performance:storage and I/O, GPU throughput, distributed training, CPU-based training, cost • Model performance:data augmentation, initializers, optimizers, etc. • Level 666: you should be familiar with Deep Learning and MXNet