Behavioral Variance – A Root Cause in Software Performance Variance
A video demonstrating the futility with extreme efforts at reducing any possible performance (response time) variance in the face of inherent behavioral differences when processing even the most straightforward of service operations such as an Apache Cassandra row insertion method execution.
Stenos is the Docker of Application Performance Monitoring
A video demonstrating how Stenos can reconstruct the entire execution behavior of a software machine, a JVM process, from a Stenos image recording created by Satoris. In the video a recording of an Apache Cassandra benchmark run in the Google Cloud is recollected, simulated, on a standard workstation. In recollecting and playing back a machine episodic memory Stenos is able to augment the past with new data collection as well as visualizations.
Speed Watching Apache Kafka in Simulated Playback
A video exploring the potential of fast simulated playback of a recorded software execution episodic memory across a number of powerful visualizations created to expose the nature of software performance. The testbed for this exploration is a recorded event stream for an Apache Kafka performance benchmark is played back in both normal and speed-up modes.
Metering the Metering of Software Calls within Past and Present Episodic Memories
A video demonstrating how to extend and augment the metering engine underlying Satoris, Stenos and Simz with custom application level meters mapped to counters that are created and updated by call (probe) interceptors, in both real and simulated software machine processes.
Pruning Metered Software Episodic Memories Using Extension Points in the Probes Open API
A video demonstrating how to prune a software episodic memory of execution call traces not exceeding some clock time threshold in the multiple simulated playback (recollection) of the software execution using the interceptor and strategy extension points in the Probes Open API.
A Gap in Time – Performance Measuring What Came Before
A short video demonstrating how the gap metering extension in Satoris allows software performance engineers working in financial trading or online gaming environments to measure the time (or any other meter measure) between two paired processing tasks as if the gap time actually occurred with the latter task.
Beyond Reactive – µCon 2015
A walkthrough of various QoS for Apps demos performed during the “Beyond Reactive” talk at the µCon 2015 (The Microservices Conference). The talk itself explored various approaches to service request level resource management starting with basic back pressure and moving on to advance reservation based quality of service (QoS) and adaptive control execution (ACE) valves.
Stemming Hotspots – Apache Spark Visualized
A video demonstrating a hierarchal namespace grouped hotspot visualization of Apache Spark in online execution as well offline machine simulation via the playback of a recorded software episodic memory. Also shown is the ability to observe and track both the overall cumulative total as well as marked cumulative total as software execution progresses.
Stripped to the Frame – Apache Spark Visualized
A video demonstrating a novel thread stack frame visualization of Apache Spark in online execution as well offline machine simulation via the playback of a recorded software episodic memory. The visualization affords the ability to inspect the execution of similar caller-callee code chains across multiple concurrent processing threads over phases in the execution.
Threads of Call Flow – Apache Spark Visualized
A video demonstrating two novel visualizations for inspecting the call flow nature of Apache Spark’s software execution behavior at particular points in time or over the duration of many very brief time windows. In addition both visualizations provide the ability to discern and inspect the thread traffic passing through such tree paths as well as the location of possible congestion pileups or parking locations for threads.
Crossing Process and Programming Language Boundaries with Software Memories and Simulated Machines
A video demonstrating how software memories and simulated machines can allow augmentation of software, post execution, that crosses process and programming language boundaries. In the demonstration Ruby code executed by the JRuby VM is mirrored over into a machine simulation that responds to the played back, recorded or streamed, execution with code written in the Java programming language.
Blinking is Seeing – Apache Spark Visualized
A video demonstrating a visualization of Apache Spark software execution at the microsecond level across multiple threads revealing interesting repeating patterns of hotspot call invocations that represent the essence of the software behavior.
The Rise and Fall – Apache Spark Visualized
A video demonstrating an extremely useful visualization that can help visually discern possible execution performance phases of a software system such as Apache Spark – a big data solution on the JVM. Using the Satoris stellar metering extension multiple configurable time windows are created that depict the inherent (self) time of hotspot methods scoped to the window (or possible phase).
The Marking of Adaptive Software Memories
A video demonstrating how the repeated playback of a particular recorded software memory can be recollected slightly differently, each time and with each mark, when the machine simulation reenacting the episodic memory employs adaptive mechanisms in the perception of recalled events resulting in the creation a more refined application performance model.
Self Reflecting Software Within Mirrors & Memories
A video demonstrating how metered Java software extends the Java platform reflection capabilities with behavioral introspection that not only works during execution but also when mirrored to another process as well as when recollected as an episodic memory.
Creating New Software Memories from Simulated Episodic Memory Recall
This video demonstrates how during the recollection of a software machine episodic memory new memories can be created of a very different nature. An integration with Neo4j, a graph database, is deployed into a simulated machine (dream sequencing) whereby it intercepts the simulated entering and exiting of method call invocations by individual threads and creates corresponding nodes (threads, frames and names) within a graph database for visualization and ad hoc querying.
Intelligent Agents That Learn To Forget Remembered Past Software Memories
This video demonstrates some of the ways the Satoris intelligent software profiling agent, that is the foundation for Stenos simulated playback, can be configured to partially forget recalled episodic memories, previously recorded, in order to cleanse a consolidated software machine performance model of uninteresting metered calls.
Stripes – A Novel Thread Stack Visualization
A video demonstrating a new way of visualizing the behavioral dynamics of thread call stacks taking into account that many call frames have a duration (on the stack) that is simply not observable to us (humans) without first slowing down time. The visualization is able to depict characteristics of a threads call path execution without manipulating time by sizing frames based on the cumulative clock time metering total of the method associated within the frame as a proportion of the overall cumulative metering total for the thread. In the video an episodic software memory of an Apache Cassandra process execution is played back within a simulating, but still real, JVM runtime that has the stripes metering extension enabled.
Sensing Software Machines – PingPong Revisited
Revisiting the PingPong demonstration in which software machines are shown to project outwards software execution behavior as well also observe, perceive and reenact other software machine execution projections mimicking the simulation of minds that occurs in humans. With some code refactoring the demo now shows how PingPong can be run local in the same process as well as remotely in different processes without any code changes to the game itself. In addition the Pong machine is stimulated into action by the playing back of a recorded episodic memory of a Ping process.
Beyond Metrics and Logging with Metered Software Memories
This screen recording demonstrates how metrics represented as JMX MBeans can be recreated from software memories that are mirrored, recorded and played back within a software machine simulation showing how ill-conceived our thinking may be in viewing metrics and event logging as primary data sources for monitoring agents.
The Power of Now – Interactive Monitoring of Apache Cassandra
A video demonstrating interactive real-time performance monitoring of a Java application instrumented by the Satoris agent and visualized by the Satoris monitoring client console. It shows how to observe the execution behavior of individual Java methods executed across one or more threads in 1 second intervals. The power of this NOW experience offers new insights not discernible in tabulated benchmark results or charts rendered by metric sampling monitoring systems.
A JVM Profiling Agent that does the work of a Software Performance Analyst
One would expect a JVM profiling agent to be an extension of a performance engineer/analyst reaching deep into a machine environment and holding the same behavioral traits and characteristics, in particular intelligence and adaptiveness. In this video I demonstrate the true power of an agent in automatically pruning measuring and data collection down to the essence of a softwares execution behavior. I use the Hazelcast (big) data grid solution as the test bed application to profile in the cloud.
Profiling Low Latency JVM Applications with Instrument-Measure-Refine-Repeat (IMRR)
A video demonstrating how to iteratively instrument and measure the performance of a JVM application using both online and offline adaptation of a profiling agent in order to derive the most accurate performance hotspot model. I use the VoltDB 5.0 server software deployed to machines in the Google Cloud as the testbed for this novel performance analysis approach.
A Near Real-Time Surveillance Console for the JVM
A video demonstrating how with a very small amount of Java code embedded within a simulated JVM runtime it is possible to create an advanced supervisory console that automatically detects and inspects JVMs launched in a datacenter as well as JVM threads started within them and the methods invoked.
Real-Time Interactive Monitoring of Java Code Concurrency Levels
A video demonstrating how the queue metering extension included within Satoris offers real-time interactive performance insight into the concurrent execution behavior of Java method bytecode. Apache Cassandra is used within the video as the testbed application.
Ping and Pong – Duality in Mirrored Software Java Machinery
A video demonstrating how software machines can not only project outwards software execution behavior, but also observe, perceive and reenact other software machine execution projections mimicking the simulation of minds that occurs in humans.
Visualizing Software Performance Benchmark Variances in Hindsight
A video demonstrating how metered software execution behavior that is recorded and played back (simulated) can be used to better understand the performance contribution variance of particular hotspot methods, during a benchmark run as well as across multiple benchmark runs.
Microservice Calls Echoing Across Space and Time
A video demonstrating an alternative and revolutionary new approach to addressing service-to-service interaction and integration design in the decomposition of monolithic systems into many loosely coupled execution units using mirrored simulation of execution behavior and context.
Temporal & Contextualized Software Performance Analysis with Mark and Tag
A video demonstrating how to tag and mark the measured software execution behavior of a Java application such as Apache Cassandra in a local and distributed context (via mirrored simulation). Also shown in the video is how mirrored simulation allows augmentation in terms of additional data collection such as tracking (call tree) in another space.
Averaging Software Performance Measurement
A video looking at how should performance averages for a method be calculated especially when the method is overloaded and chained as well as being recursive (direct) or reentrant (indirect)? Also discussed is an approach to software performance outlier analysis based on activity theory and the three levels it defines in understanding human behavior now applied to software.
An Innovative Interactive JVM Thread Stack Analysis Method
A video demonstrating an innovative approach to JVM thread call stack analysis based on unique identification of instrumented method call stack frames with the ability to interactively inspect, mark and tag such frames across 100s of threads with a single click from within the Satoris monitoring console.
Offline Playback of Distributed Software Execution in the Google Cloud
This video demonstrates how using Satoris, Simz and Stenos monitored applications can stream their software execution behavior from multiple JVM runtimes into a single “control & observation plane” JVM that not only simulates the playing back of the mirrored software execution but also streams it to a file system for offline simulated playback creating an “active” software behavior database in contrast to typical state based metric monitoring databases.
A Time Machine for Augmenting Past Software Execution in the Cloud
What if you could go back in time when your was application running in the cloud performing some service request and inject code into the execution flow that augments this new simulated reality to gain insights and extend the reach of your software behavioral analysis in a very natural manner that is not readily distinguishable from the reality it mirrors? In this video I show how I can change the space and time dimensions in the monitoring of a DataStax Cassandra server running on the Google Cloud platform using Aspect Oriented Programming (AOP) like interception of present and past code execution.
Aggregated Performance Analysis of OpenJDK JMH Benchmarks with Satoris & Simz
A video demonstrating how to obtain fine grain aggregated performance analysis of a micro-benchmark suite executed by the OpenJDK JMH tool. Using the Pivotal Reactor Benchmark as a test case I also introduce IMRR, a novel approach to performance instrumentation and measurement of extreme low latency benchmarks. IMRR is an iterative process consisting of 4 steps – Instrument, Measure, Refine and Repeat.
Stemma – A New JVM Performance Profile Namespace Grouping Visualization
A video demonstrating a new way of beautifully visualizing the grouping of Java and JVM performance profiles for methods by class and namespace packages in a dynamic context, including the marking of measurement data and tracking of delta from a particular point in time. The visualization is tested with DataStax Cassandra and VoltDB.
Metering, Mirroring & Simulating 140 Million Software Execution Call Events a Second on the Google Cloud Platform
A video demonstrating the amazing throughput of Satoris and Simz in metering, mirroring (recording) and simulating (playback) software execution behavior from multiple source JVMs into a single JVM running on a single machine hosted on the Google Cloud Platform.
Large Scale Teleportation of Metered Software Execution Behavior in the Cloud
A video demonstrating the ability to teleport the software execution behavior of multiple JVM based applications over into another single remote JVM runtime at an unbelievable event processing throughput rate of nearly 200 MILLION events a SECOND!
Revisiting the Java/JVM Spotlight Visualization
A video demonstration some further refinements to the probe (method) spotlight visualization using the Scala compiler build as the test bed for such options as: trim, glow and separator. In addition Stenos is used to show how a single software execution behavior recording can be played back multiple times with different options and different visualizations.
Code in Motion – An Interstellar Inspired Visualization for the JVM
A video showing a new and very innovative application software performance monitoring visualization that offers millisecond motion display of code execution flow for hotspot methods in the Oracle JVM. The visualization is used to reveal software behavioral patterns never before seen with any other profiling tool for software products/projects such as DataStax (Apache) Cassandra, Hazelcast Cluster Data Grid and the now infamous Scala compiler.
Visualizing a Machine Blink of Low Latency JVM Code Execution
A video demonstrating an innovative approach to microscopic performance measurement and visualization of low latency software execution behavior; across threads, up and down the stack, for call frames having a duration as low as a single microsecond. The visualization is tested with DataStax Cassandra, Hazelcast and the Scale compiler.
Slipstream – A New Thread Stack Dump Capture & Visualization Approach
A video demonstrating a new way of capturing and visualizing JVM thread stack dumps that scales to the demands of multi-threaded runtime and beautifully callouts the most salient aspects of call stacks. The video also shows how this extension to the Satoris metering engine can be plugged into a simulating runtime offering instant distributed multi-JVM thread stack dump analysis. The visualization is tested with DataStax Cassandra and VoltDB.
Shining a Spotlight on Java/JVM Software Method Execution
A demonstration of a new software execution visualization I’ve designed and developed as part as a set of visual metering extensions I’m creating to explore various different behavioral patterns on Java/JVM platform and to shine a spotlight on adaptive performance monitoring (and why it is the only game in town when it comes to software analytics and performance monitoring & management). The visualization is tested out with Vert.x, DataStax Cassandra, Hazelcast and the Scala compiler.
Visualizing The Frequency Of JVM Thread Call Stack Frame Depths
A new innovative visualization that displays the cumulative and recent frequency of method invocation at various call stack depths across multiple threads within a JVM. In the demonstration a number of web containers are visualized including Oracle Glassfish, Apache Tomcat, Vert.x as well as the Scala Compiler.
Oracle Glassfish 4.0 Uncovered – Interactive Adaptive Monitoring
A video employing various different application performance monitoring visualizations in profiling and tracing the execution of a simple HTTP static file request generated by siege and served by the Oracle Glassfish application server.
Profiling the Typesafe Activator Reactive Stocks Application
A video demonstrating the integration of the Satoris metering (profiling) agent within the Typesafe Platform Stack that includes Play and Akka. The monitoring of the software execution behavior is done using the Satoris monitoring console client as well as an innovative new tree of life visualization.
The Tree of Life – Software Execution Animated & Adaptive
A video demonstrating a very cool new dynamic visualization that renders sampled metered call pathways within an enterprise software application, DataStax Cassandra, showing clearly how the built-in adaptive measurement features of Satoris whittle down a very large tree space to something far more manageable representing the execution essence of a software.
Managing Fast and Slow Service Requests with Application Level QoS
A matrix style demonstration of how QoS for Apps allows Operations to more effectively manage the performance of enterprise systems with different transactional mix workloads by dynamically injecting control flow policies into methods (code blocks) at runtime.
Protecting Software Services & Resources Using Adaptive Control
Demonstrates how adaptive control can protect a resource, local or external, through the use of a thread execution valve dynamically injected into software at runtime that automatically senses a problem with a called service or consumed resource and then temporarily suspends execution.
Performance Monitoring Mule ESB with Satoris
A walk through of the integration steps in instrumenting and performance monitoring the Mule ESB Enterprise Edition. Using the Widgets examples included in the distribution to generate workload, that is then adaptively metered, the walk through encompasses the interpretation of various visualizations and measurements displayed in the monitoring console client.
Everything is a Microservice – Physical vs Logical
A screen recording demonstrating how a microservice architected system might perform in launching hundreds of small Java applications and how the logical model, via a mirroring simulation, allows us to more easily inspect and reason about the physical model of such type of deployments.
Replicated Simulated Playback is like the Java 8 Stream API on Steroids without Java 8
A video demonstrating how the streaming of metered software execution behavior over from an actual application process to another online simulation process or recording file is the ultimate in functional pipeline processing when coupled with the ability to dynamically filter, re-meter/-record (map), and aggregate (reduce) such simulated (played back) behavior.
Fun Software Simulated Playback & Graphical Augmentation Demo
A really cool and fun screen video that shows how software can be augmented with new behaviors across space and time. Check out how a probes events can be graphically interpreted and replayed with a little canvas metering extension I created in less than an hour.
Simulating Remote Procedure Calls with Satoris and Simz
Another demonstration of the upcoming Simz 1.3 release showing how using the Probes Open API we can drive the behavior in a simulated runtime both in terms of task/activity but as well as environment date set in the client and replicated to the simulation.
Simulating A Minecraft Game Simulation with Satoris and Simz
A screen recording showing how Simz can simulate the playback of software execution behavior in a JVM running the Minecraft game and instrumented with the Satoris agent. Monitoring both the real and mirror JVM there is no discernible difference within the Satoris monitoring console client.
Can (Virtual) Machines Dream? A Simulated Playback of a Hazelcast Cluster
A demonstration of how metered software execution behavior can be recorded and played back offline, creating a very realistic simulation of the application that can be used for machine training and learning purposes as well as querying.
Monitoring a Hazelcast Cluster with Satoris & Simz
A screen recording, with audio, explaining how Simz and Satoris gives immediate feedback on the performance within a distributed JVM based system in particular one, such as Hazelcast, that is dynamic in it’s balancing of client request workload across a set of nodes (coming and going).
Adaptive Application Performance Measurement
A screen recording showing the adaptive instrumentation and performance measurement mechanism built into the Satoris FREE Community Edition. Satoris itself comes with many more advanced adaptive mechanisms, both for control and monitoring, but the hotspot metering extension is probably the most effective in getting an immediate understanding of the execution behavior of a system.
Adaptive Control in Execution (ACE) – Throughput Optimization
Demonstrates the tvalve metering extension included in the upcoming Sentris 1.2 release. The metering extension adaptively controls the degree of concurrency passing (calling) through externally defined valves attached to probes that are dynamically inserted into instrumented Java class bytecode. In the screen recording we compare AtomicLong with the new LongAdder class included in Java 8.
QoS for Apps – Services & Resources Intro
A screen recording explaining the basic Quality of Service (QoS) principles underlying the Sentris QoS metering extension, which extends the monitoring capabilities of Satoris with the ability to control metered thread execution flow via an externally defined dynamic systems model.