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.

Fast Recall of Recorded (Logged) Software Execution Behavior

A video showing the speed advantage Stenos has over standard logging frameworks in recollecting software execution behavior that has been recorded or logged in both single and multi-threaded contexts.

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.

Microbenchmarking Big Data Solutions on the JVM – Part 1

A video demonstrating the online and offline adaptive profiling capabilities of the Satoris agent in the context of microbenchmarking  Apache Spark, a Big Data solution, on the JVM.

Microbenchmarking Big Data Solutions on the JVM – Part 2

A video demonstrating use of the Satoris tierpoint metering extension in refining the performance (profile) model of a large intricate software system, such as Apache Spark, along subsystem and component boundaries.

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.

Controlling Time and Motion of Simulated Software Memories

This video demonstrates the usefulness of time manipulation within the simulated playback of software episodic memories from the perspective of both the simulation (actor/action) as well as the visualization (observer/change).

Software Memories vs Event Sourcing

This video demonstrates a few of the many important differences between software (episodic) memory recording and playback in comparison with typical event production & consumption using json as the example data (payload) format.

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.

Selective Memory Strategies in Software Performance Analysis

A video demonstrating how the concept of selective memory can be applied to the software performance analysis of both online and offline application (activity) execution behavior.

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!

Simz – Bringing Extreme Volume and Velocity to BIG DATA in the Cloud

A video demonstrating the latest build of Satoris and Simz clocking more than 200M remote application performance monitoring (APM) events/sec in the Google Cloud. Another record breaking benchmark run!

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.

Vert.x 2.2 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 Vert.x web container.

Apache Tomcat 7.0/8.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 Apache Tomcat web container.

Caucho Resin 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 Caucho Resin web container.

Typesafe Play 2.x 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 Typesafe Play framework stack.

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.

Adaptive Performance Monitoring: JBoss Wildfly 8.1.RC1

A video demonstrating how far more important adaptive performance monitoring is than the typical monitoring conference debate around various statistical measures such as the “average”.

Scaling Down The Scala Compiler Dragon: Call Tree Visitation Visualized

This is an extraordinary look at what happens, in terms of call path traversal, when the Scala compiler does actually compile Scala code, in this case the Scala SDK.

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.

Profiling the Scala Language Compiler with Satoris

A sort video demonstrating how to use Satoris to profile the Scala language compiler in compiling its own library code base.

QoS Rate Limiting of Long Running Software Service Requests

A video demonstrating how rate limiting offers an additional means of ensuring performance guarantees for normally fast running service requests that compete for resources alongside longer running requests.

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.

Adaptive Control of Software Execution – Neo (The Matrix) Style

A Matrix style dynamic runtime visualization of how adaptive control valves bring real operational control to the management of software systems by temporarily taking over thread execution processing.

Performance Monitoring DataStax Apache Cassandra

A walk through of the integration steps in instrumenting and performance monitoring the DataStax Cassandra. During this demonstration we highlight some initial behavioral observations rendered in the Satoris monitoring client console.

The Matrix Reloaded – Mirrored Microservices

A demonstration of how a mirroring software simulation runtime such as Simz allows you to observe in real-time the call stack execution behavior of 100s of threads across 100s of Java runtimes.

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.

Flog The Loggers – Why Logging is not Monitoring!

A video demonstrating the performance overhead and storage costs introduced by the use of logging compared to metering with recording capabilities enabled, allowing for the later playback and simulation of metered software execution behavior.

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.

Collective Software Intelligence via Distributed Replication & Simulated Playback

A cool new visual demonstration showing how we can augment the collective execution behavior of multiple software applications within a single simulation that can be both online as well as offline.

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.

Data in Motion – Offline Software Execution & Variable State Playback

A video demonstrating the new contextual data recording and simulated playback enhancements coming in the Stenos 1.3 release – an active database for metered (profiled) software execution behavior.

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.

Data in Motion – Simulated Software State and Behavior

Demonstrates some exciting new state replication & state inspection features and extensions coming to 1.3 releases of Satoris, Stenos and Simz.

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.

Performance Profiling The BigSwitch OpenFlow

A screen recording showing how to instrument and performance monitor the BigSwitch OpenFlow “Floodlight” Network Controller.

Performance Profiling The OpenDaylight Network Controller

A screen recording showing how to instrument and performance monitor the OpenDaylight Network Controller using the Floodlight CBench tool to generate OpenFlow packet data workload.

Performance Profiling Eclipse Jetty with Satoris

A performance analysis walkthrough of Eclipse Jetty 9 profiled with the Satoris 1.2 adaptive metering engine.

Cost Aware Runtimes & Services (CARS) – Hazelcast Monitoring

A screen recording discussing cost awareness within the metering engine from the point of view of the hotspot and budget metering extensions and applying them both to monitoring (metering) a Hazelcast server.

Intelligent Metering – Budget Based Probe Measurement

Demonstrates the budget metering extension that will be freely available in the upcoming Satoris 1.2 release. Using a budgetary control mechanism this metering extension compliments the existing hotspot adaptive metering extension.

QoS for Apps – Hazelcast Distributed Map Request Processing Control

A screen recording demonstrating how quick and easy it is to introduce reservation based resource management, for the purpose of control, into a Hazelcast server using the QoS metering extension included in Sentris.

QoS for Apps – JBoss Wildfly HTTP Request Processing Control

A screen recording demonstrating how quick and easy it is to introduce reservation based resource management, for the purpose of control, into a Java web application using the QoS metering extension included in Sentris.

QoS for Apps – Adaptive Resource Valves

Demonstrates how adaptive control valves attached to QoS resources can automatically determine the optimal capacity level of a resource both global or locally within a particular QoS service classification.

Parallel Simulated Machine Universes with Simz

Demonstrates how Simz, a software execution mirroring system for the JVM, can itself be mirrored to another Simz runtime by enabling the simz metering extension within a Simz runtime.

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.

QoS for Apps – Contextual Resource Prioritization

A screen recording demonstrating two approaches to contextual prioritization of thread execution using the Probes Open API and the qos metering extension included in Sentris.

QoS for Apps – Resource Latches & Barriers

A screen recording demonstrating the use of latches and barriers applied to QoS Resources in controlling and synchronizing work across multiple QoS service executing threads.

QoS for Apps – Time Based Resource Reservation

A screen recording demonstrating the use of the timer reservation strategy in determining the required units that need to be reserved by a QoS Service from a particular QoS Resource.

QoS for Apps – Resource Reserve Pools

A screen recording demonstrating the use of QoS resource reserve pools (re)defined at the QoS service level that reduce QoS resource reserve management overhead across multiple QoS services when workload is within normal ranges.

QoS for Apps – Composite Resource Reservation

A screen recording demonstrating the use of multiple Sentris QoS resources in controlling peculiar software execution behavior across QoS classified services.

QoS for Apps – Reservation Lanes

A screen recording demonstrating how the QoS metering extension included with Sentris can prioritize differently the execution of code and paths within applications (and containers) based on resource reservation lanes.

QoS for Apps – Service Prioritization

A screen recording demonstrating how the QoS for Apps metering extension, included with Sentris, gives developers and operations staff the ability to control and prioritize differently the execution of code and paths within applications (and containers).

QoS for Apps – Rate Limiting

A screen recording demonstrating how easy it is to introduce QoS based call/API rate limiting into any Java application or Ruby application (when run on the JRuby VM) with the Sentris QoS metering extension.

QoS for Apps – Nested Service Classification

A screen recording demonstrating the support for nested service classifications within the Sentris qos metering extension as well as the redefinition of a resource pool within the scope of a particular QoS service flow.