1. What is the DOM?

The Document Object Model (DOM) is a standardized programming interface that represents web documents (HTML, XML) as a hierarchical tree of objects, allowing programs and scripts to dynamically access, manipulate, and update the content, structure, and style of documents.

Originally developed by the World Wide Web Consortium (W3C) and refined by the WHATWG, the DOM serves as a bridge between web content and scripting languages like JavaScript. When a browser loads a web page, it parses the HTML markup into a DOM tree, turning elements, attributes, and text into objects that can be accessed and modified through APIs.

The DOM’s key purpose is to enable interactive and dynamic web applications, allowing developers to programmatically alter the content and appearance of web pages in response to user actions, network events, or time-based triggers.

Historical Context

• The concept originated in the mid-1990s alongside the rise of dynamic webpages.
• Early DOM implementations varied between browsers, leading to compatibility issues.
• The W3C standardized the DOM to create uniformity.
• Modern browsers have largely converged on this standard, with incremental extensions and performance improvements.

2. Major Use Cases of the DOM

2.1 Dynamic Content Updates

One of the primary uses of the DOM is updating webpage content dynamically. For example, modifying text, images, or entire sections without reloading the page. This underpins interactive behaviors such as live search suggestions, content filters, and updating data visualizations.

2.2 Event-Driven Programming

The DOM provides an event system that allows capturing and responding to user interactions like clicks, key presses, form submissions, mouse movements, and more. This capability is foundational for interactive web apps.

2.3 Form Validation and User Input Handling

By accessing form elements and their values via the DOM, developers can perform client-side validation, provide instant feedback, or enhance forms with dynamic fields.

2.4 Animations and Visual Effects

The DOM API allows scripts to change CSS properties in real-time, enabling animations, transitions, and dynamic styling changes that improve user experience and engagement.

2.5 AJAX and Partial Page Updates

Using the DOM in conjunction with AJAX techniques, web apps can fetch data asynchronously and update parts of the page dynamically without full reloads, resulting in smoother, faster interfaces.

2.6 Building Complex UI Frameworks and Libraries

Popular JavaScript frameworks (React, Vue, Angular) abstract the DOM by introducing concepts like the virtual DOM to efficiently manage and update user interfaces at scale.

2.7 Accessibility Features

Through the DOM, developers can ensure proper semantic markup, ARIA attributes, and interactive behaviors that assistive technologies use to provide accessibility for users with disabilities.

3. How the DOM Works Along with Architecture

3.1 DOM as a Tree of Nodes

At its core, the DOM models a document as a tree structure composed of various types of nodes:

• Document Node: The root node representing the entire document.
• Element Nodes: Represent HTML elements such as <div>, <p>, <a>.
• Attribute Nodes: Describe attributes of elements like class, id.
• Text Nodes: Contain the actual textual content inside elements.
• Comment Nodes: Represent HTML comments.
• DocumentFragment Nodes: Lightweight containers used for batch operations.

Each node is an object exposing properties and methods to traverse and manipulate the tree, forming parent-child and sibling relationships.

3.2 Layers of the DOM Architecture

The DOM architecture can be conceptually divided into:

• DOM Core: Defines the fundamental interfaces and structures for any document type.
• DOM HTML: Extends DOM Core with interfaces specific to HTML documents.
• DOM Events: Defines event models including capturing, bubbling, and event propagation.
• DOM Style: Provides access to CSS styles and computed style information.

3.3 Browser Parsing and Rendering Pipeline

• The browser receives HTML from the server.
• HTML Parser converts the markup into the DOM tree.
• CSS is parsed into the CSS Object Model (CSSOM).
• The DOM and CSSOM are combined into the Render Tree, which determines what is displayed.
• Layout and painting are performed based on the render tree.
• JavaScript interacts with the DOM, potentially modifying it and triggering reflows and repaints as necessary.

4. Basic Workflow of DOM Manipulation

4.1 Accessing Elements

You can locate nodes within the DOM tree using various APIs:

• getElementById(id) — finds element with the specified id.
• getElementsByClassName(className) — returns elements with a class.
• getElementsByTagName(tagName) — retrieves elements by tag name.
• querySelector(selector) / querySelectorAll(selector) — modern, flexible selectors.

4.2 Reading and Modifying Content

• innerHTML and textContent read or set HTML/text inside elements.
• Attributes can be read or modified using getAttribute() and setAttribute().

4.3 Creating and Adding Elements

• document.createElement(tagName) creates new nodes.
• Nodes are inserted using methods like appendChild(), insertBefore(), or modern append().

4.4 Event Handling

• Attach event listeners with addEventListener(eventType, handler, options).
• Events propagate through capturing and bubbling phases.
• Event delegation optimizes handling by attaching listeners to parent elements.

4.5 Removing or Replacing Nodes

• Nodes can be removed via removeChild() or directly with element.remove().
• Replace nodes using replaceChild().

5. Step-by-Step Getting Started Guide for DOM

Step 1: Access a DOM Element

<p id="demo">Hello World</p>

<script>
  const p = document.getElementById('demo');
  console.log(p.textContent);  // Outputs: Hello World
</script>

Step 2: Change Element Content and Style

p.textContent = "DOM Manipulation is fun!";
p.style.color = "green";

Step 3: Create and Insert New Elements

const newDiv = document.createElement('div');
newDiv.textContent = "New Div Element";
document.body.appendChild(newDiv);

Step 4: Add Event Listener to Element

newDiv.addEventListener('click', () => {
  alert('Div clicked!');
});

Step 5: Remove an Element

newDiv.remove();

6. Advanced DOM Concepts

6.1 Event Propagation

• Capturing phase: Event trickles down from the root to the target.
• Target phase: Event reaches the target.
• Bubbling phase: Event bubbles up from target to root.

Understanding this is key for effective event handling strategies.

6.2 Mutation Observers

Used for watching changes in the DOM without inefficient polling. Useful in frameworks and plugins to react to DOM modifications.

6.3 Shadow DOM and Web Components

Shadow DOM provides encapsulation by isolating part of the DOM subtree and CSS from the main document, enabling reusable custom components.

6.4 Performance Optimization

• Batch DOM updates to minimize layout thrashing.
• Use DocumentFragment for multiple insertions.
• Avoid excessive reflows and repaints.

7. Summary

The Document Object Model is fundamental to modern web development, serving as the backbone that enables dynamic, interactive, and rich web experiences. Mastery of the DOM — from tree structure, event handling, and manipulation APIs to advanced concepts like shadow DOM and mutation observers — equips developers to create responsive, accessible, and performant applications.

The ability to control and react to changes within the DOM is what transforms static webpages into dynamic web apps that respond seamlessly to user input and real-time data.

The post DOM Deep Dive: Architecture, Use Cases, Workflow, and Practical Guide appeared first on scmGalaxy.

1. New Relic

New Relic is a comprehensive performance monitoring and profiling tool that provides detailed insights into the performance of web applications. It helps developers monitor real-time application performance, identify bottlenecks, and optimize code execution. New Relic offers a range of features, including APM (Application Performance Management), error tracking, infrastructure monitoring, and real-time analytics. It integrates with cloud platforms like AWS and Azure, providing full-stack visibility to help teams improve application performance and user experience.

2. Dynatrace

Dynatrace is an AI-powered performance monitoring tool that offers full-stack observability, from frontend to backend. It automatically detects and visualizes the entire application environment, including microservices, containers, and cloud infrastructure. Dynatrace’s profiling features allow users to pinpoint performance issues in real-time and analyze transaction-level data to optimize application performance. Its AI-driven insights help to identify anomalies, reduce downtime, and optimize system performance across the board.

3. AppDynamics

AppDynamics is a robust performance management tool designed to monitor and profile applications in real-time. It allows teams to track user experience, monitor application behavior, and identify performance bottlenecks. AppDynamics provides deep diagnostic capabilities, including transaction tracing, error reporting, and code-level insights. With its ability to monitor both cloud and on-prem environments, AppDynamics is ideal for performance profiling in complex, distributed systems.

4. JProfiler

JProfiler is a Java profiling tool that provides deep insights into the performance of Java applications. It helps developers analyze CPU, memory, thread, and garbage collection behavior in real-time. JProfiler supports various Java frameworks and application servers and offers powerful tools like heap dumps, CPU sampling, and thread profiling. The tool also integrates with IDEs like IntelliJ IDEA and Eclipse, making it easy for developers to profile applications during the development process.

5. VisualVM

VisualVM is an open-source profiling tool for Java applications that provides various monitoring, troubleshooting, and performance profiling features. It allows users to monitor JVM memory usage, CPU consumption, thread activity, and garbage collection. VisualVM supports the visualization of heap dumps, and it can also be used for profiling remote applications. It is a versatile tool that provides both performance monitoring and memory analysis, helping teams optimize their Java applications.

6. YourKit

YourKit is a powerful Java and .NET profiler known for its rich feature set, including CPU, memory, and thread profiling. It helps developers identify performance bottlenecks in real-time by analyzing memory usage, CPU load, and thread behavior. YourKit provides detailed views of the application’s memory allocation, garbage collection performance, and CPU usage, helping teams optimize their applications for better performance. It also supports various frameworks and JVM-based languages, making it a go-to tool for Java developers.

7. Apache JMeter

Apache JMeter is an open-source tool primarily used for performance testing and profiling web applications. It allows teams to simulate various load conditions and profile how applications perform under stress. JMeter can be used to measure response times, throughput, and server resource usage under heavy load, making it ideal for load testing, stress testing, and performance profiling. Its versatility extends to testing different types of applications, including databases, web servers, and APIs.

8. gProfiler

gProfiler is a performance profiling tool designed for C, C++, and Python applications. It allows developers to analyze CPU usage, memory allocation, and function-level performance in real-time. gProfiler provides detailed visualizations of how functions and methods interact, helping teams identify performance bottlenecks. It integrates with various debugging tools and supports multi-threaded applications, making it an essential tool for profiling low-level applications.

9. Valgrind

Valgrind is a programming tool used for memory debugging, memory leak detection, and profiling applications. It supports C, C++, and other languages, providing developers with detailed insights into memory usage and performance bottlenecks. Valgrind includes tools like Callgrind, which helps analyze CPU cache misses and profiling function calls, and Massif, which tracks memory usage. Valgrind is especially useful for identifying memory leaks and performance issues in complex applications.

10. Xdebug

Xdebug is a PHP extension that provides powerful debugging and profiling features for PHP applications. It enables developers to profile the execution of PHP code, analyze memory usage, and track function calls. Xdebug integrates with various IDEs like PHPStorm, providing an intuitive interface for debugging and profiling PHP applications. It also includes features like stack trace generation and code coverage analysis, making it an essential tool for performance profiling in PHP.

11. Flamegraph

Flamegraph is a performance profiling tool that visualizes profiling data in the form of a flame graph. It helps developers analyze CPU performance and identify areas of the application where time is spent most frequently. Flamegraphs provide a clear, hierarchical visualization of call stacks, making it easy to identify performance bottlenecks in both CPU and memory usage. Flamegraph supports various languages and platforms and is often used in combination with other profiling tools to provide detailed insights into application performance.

12. Chrome DevTools

Chrome DevTools is a set of web development tools built into Google Chrome that allows developers to monitor, debug, and profile web applications. It includes a powerful performance profiler that tracks CPU and memory usage, network activity, and rendering performance. The tool enables detailed analysis of how a web page or application performs in the browser, helping developers optimize page load times, reduce resource consumption, and improve the overall user experience.

13. Flamegraph.js

Flamegraph.js is a JavaScript tool that visualizes performance data in the form of a flame graph. It helps developers analyze JavaScript performance by visualizing the time spent in various functions and identifying performance bottlenecks. Flamegraph.js integrates with browser-based tools and can be used to track the performance of JavaScript applications, making it an essential tool for frontend developers looking to optimize their web applications.

14. JProfiler

JProfiler is another powerful Java profiling tool that allows for in-depth analysis of CPU, memory, and thread performance. It offers features like heap dumps, CPU sampling, and thread profiling to identify memory leaks and performance bottlenecks. JProfiler integrates with popular IDEs such as Eclipse and IntelliJ IDEA, and supports profiling applications in production environments. It provides a detailed view of how Java applications use system resources, enabling developers to optimize application performance efficiently.

15. AppDynamics

AppDynamics is a powerful performance monitoring and profiling tool that offers real-time analytics of application performance. It tracks the performance of web applications, mobile applications, and microservices across the entire stack. AppDynamics helps teams detect anomalies, measure transaction times, and monitor infrastructure in real time. It integrates with cloud platforms and enterprise systems, providing a complete view of the application’s health and performance.

16. ProfilingTools by Intel

Intel’s ProfilingTools is a suite of performance analysis tools designed to help developers optimize the performance of their C, C++, and Fortran applications. It includes tools for CPU profiling, memory analysis, and GPU profiling. Intel’s tools provide detailed insights into application performance, helping teams identify critical sections of code that need optimization. The suite is highly optimized for Intel processors, providing accurate and detailed data about system resource usage.

17. DTrace

DTrace is a dynamic tracing tool for troubleshooting performance issues in real-time across various platforms. It supports a wide range of applications and services, including databases, web servers, and operating systems. DTrace enables developers to monitor system calls, memory usage, and CPU performance, providing detailed data on application performance in production environments. Its flexibility and low overhead make it an invaluable tool for performance profiling in complex, multi-layered systems.

18. Nginx Amplify

Nginx Amplify is a monitoring and profiling tool specifically designed for applications running on the Nginx web server. It provides real-time monitoring of server performance, including response times, request counts, and CPU usage. Amplify helps teams identify issues with Nginx configurations, optimize resource usage, and improve application performance. It also integrates with cloud platforms and supports custom metrics to tailor monitoring for specific use cases.

19. Rookout

Rookout is a live debugging and profiling tool that allows developers to collect real-time data from production environments without affecting user experience. Rookout provides deep insights into performance metrics, including CPU usage, memory consumption, and thread activity. The tool enables teams to profile applications in real-time and adjust performance settings without needing to halt production, making it a valuable tool for optimizing live applications.

20. iStat Menus

iStat Menus is a system monitoring tool for macOS that provides detailed statistics on system performance. It tracks CPU usage, memory usage, disk activity, network usage, and more. iStat Menus offers a user-friendly interface that enables developers to monitor system performance in real-time and identify bottlenecks. It’s especially useful for tracking resource consumption in development environments and optimizing application performance on macOS systems.

21. AppOptics

AppOptics is a cloud-based application performance monitoring tool that provides insights into web and mobile applications. It tracks performance metrics, including transaction times, error rates, and system resource usage. AppOptics also offers distributed tracing, allowing teams to pinpoint performance bottlenecks across microservices. Its intuitive dashboards and reporting features make it easy for teams to track performance metrics and optimize their applications in real time.

This list provides a comprehensive overview of the tools available for performance profiling across various platforms. Let me know if you’d like more details or adjustments!

The post Top 21 Tools for Performance Profiling Tools in 2026 appeared first on scmGalaxy.

Performance monitoring tools are essential for ensuring the optimal operation of applications and infrastructure. They provide insights into system performance, help identify bottlenecks, and assist in maintaining a seamless user experience. Below is an overview of the top 21 performance monitoring tools, each highlighted with its major features to assist you in selecting the most suitable option for your needs:

1. Dynatrace

Dynatrace offers a unified platform that combines broad and deep observability with continuous runtime application security and advanced AIOps. It provides intelligent automation from data, making it a comprehensive solution for performance monitoring.

2. New Relic

New Relic is an AI-powered all-in-one observability platform that provides engineers with a single source of data and insights across the stack. It breaks down silos between data, teams, and tools to help businesses optimize uptime and boost performance.

3. AppDynamics

AppDynamics, by Cisco Systems, offers deep visibility into application performance and user experience. It excels in monitoring complex, distributed applications and provides powerful analytics and automated remediation capabilities.

4. Datadog

Datadog specializes in providing a comprehensive monitoring platform for cloud applications. It collects data from diverse sources such as servers, containers, databases, and third-party services, aiming to make the stack fully observable.

5. Grafana

Grafana is a multi-platform open-source analytics and interactive visualization web application. It can produce charts, graphs, and alerts for the web when connected to supported data sources, making it a versatile tool for performance monitoring.

6. SolarWinds Server and Application Monitor

SolarWinds provides comprehensive server and application monitoring with features like dependency mapping, which helps in understanding and visualizing relationships between applications and servers. This aids in the quick identification of performance issues.

7. Site24x7

Site24x7 offers monitoring solutions suitable for educational institutions, providing custom dashboards and comprehensive monitoring capabilities for websites, servers, and applications.

8. Honeycomb

Honeycomb is tailored for online games and provides visualized system metrics, helping developers understand and improve application performance through detailed observability.

9. LogRocket

LogRocket is ideal for e-commerce companies, offering insights into user experiences by recording sessions and tracking performance metrics, which helps in identifying and resolving issues affecting users.

10. Coralogix

Coralogix provides real-time insights into application performance, helping teams to proactively identify and resolve issues before they impact users. It offers machine learning-powered anomaly detection and log clustering.

11. Instana

Instana offers automated application performance monitoring for microservice applications, providing real-time visibility and automated root cause analysis to ensure optimal performance.

12. Raygun

Raygun provides error, crash, and performance monitoring for web and mobile applications, helping developers detect and diagnose issues impacting end users. It offers real-user monitoring and detailed diagnostics.

13. Prometheus

Prometheus is an open-source systems monitoring and alerting toolkit, particularly suited for monitoring dynamic cloud environments. It features a multi-dimensional data model and a powerful query language.

14. Nagios

Nagios provides monitoring of systems, networks, and infrastructure, offering alerting services to inform users of issues. It is highly extensible through plugins and has a large community of users.

15. Zabbix

Zabbix is an open-source monitoring solution for networks and applications, offering real-time monitoring, alerting, and visualization features. It supports a wide range of platforms and is known for its scalability.

16. Splunk

Splunk provides a platform for searching, monitoring, and analyzing machine-generated data, offering powerful visualization and analysis tools to gain insights into system performance.

17. Elastic APM

Elastic APM is part of the Elastic Stack, providing real-time application performance monitoring by collecting in-depth performance metrics and errors from inside applications.

18. Pinpoint

Pinpoint is an open-source APM tool for large-scale distributed systems, offering real-time monitoring, visualization of application topology, and detailed call stack analysis.

19. SigNoz

SigNoz is an open-source APM tool that helps developers monitor applications and troubleshoot problems, providing metrics, traces, and logs in a single pane of glass.

20. SolarWinds Network Performance Monitor

SolarWinds offers comprehensive network performance monitoring, providing real-time insights into network availability and performance, helping to quickly detect, diagnose, and resolve network issues.

The post Top 21 Tools for Performance Monitoring Tools in 2026 appeared first on scmGalaxy.

http://www.joomlaaa.com/Joomla-Articles/optimization/How-can-I-make-my-Joomla-site-load-faster.html

http://www.joomlaperformance.com

http://www.websiteoptimization.com

http://www.pathos-seo.com/joomla-technical-optimization/making-a-faster-joomla-website.html

http://www.pathos-seo.com/joomla-technical-optimization/making-a-faster-joomla-website.html

http://www.wzcreativetechnology.com/joomla-tips-and-tricks/74-how-to-make-joomla-site-load-fast.html

http://extensions.joomla.org/extensions/site-management/cache/7350

http://www.open-source-depot.com/archives/13-MySQL-Performance-Tip-on-CentOS4-on-GoDaddy.html

http://www.open-source-depot.com/archives/13-MySQL-Performance-Tip-on-CentOS4-on-GoDaddy.html

http://www.cyberciti.biz/tips/enable-the-query-cache-in-mysql-to-improve-performance.html

http://forum.joomla.org/viewtopic.php?f=433&t=344013l

http://kb.siteground.com/article/How_to_optimize_a_MySQL_database_using_phpMyAdmin.html

http://www.electrictoolbox.com/mysql-optimize-table-cli/

http://forum.joomla.org/viewtopic.php?p=1250059

http://kb.siteground.com/article/How_to_optimize_a_MySQL_database.html

http://developer.yahoo.com/performance/rules.html

http://www.mightyjoomla.com/Joomla-Tips-Tricks/enable-and-use-gzip-compression-in-joomla-cms-to-enhance-website-performance.html

http://forum.joomla.org/viewtopic.php?t=50278

www.websiteoptimization.com/services/analyze/

http://forum.joomla.org/viewtopic.php?t=50278

http://www.phpmagicbook.com/htaccess-essential-tricks-for-blog-website-performance-a-guide/

http://www.dquinn.net/htaccess-adding-etags-gzip-expires-headers/

The post Joomla Website Performance appeared first on scmGalaxy.

• Application Monitoring
• Deployment Analysis, History, and Comparison
• Database Monitoring
• Availability & Error Monitoring
• Complete report
• Team Collaboration – Team can work together
• Secure

• End-to-end transaction tracing
• Troubleshooting and control
• Code level visibility
• Scalability
• Dynamic baselining and alerting
• Data retention

• Integrated transaction- and customer-centric application performance monitoring
• User Experience Monitoring
• Transaction DNA
• Advanced analytics
• Enhanced collaboration

• Application Centric Infrastructure Monitoring
• Synthetic Testing
• End user experience monitoring
• Deep dive diagnostic

• Track and alert on application health
• Group apps by business process
• Set thresholds to trigger alerts
• Ensure business services are meeting SLAs
• Supports monitoring of major application servers
• Synthetic transactions to monitor end-to-end performance

The post Top 5 Application Performance Management Tools appeared first on scmGalaxy.

Source code analysis tools: Evaluation criteria

Support for the programming languages you use. Some companies support mobile devices, while others concentrate on enterprise languages like Java, .Net, C, C++ and even Cobol.

Good bug-finding performance, using a proof of concept assessment. Hint: Use an older build of code you had issues with and see how well the product catches bugs you had to find manually. Look for both thoroughness and accuracy. Fewer false positives means less manual work.

Internal knowledge bases that provide descriptions of vulnerabilities and remediation information. Test for easy access and cross-referencing to discovered findings.

Tight integration with your development platforms. Long-term, you’ll likely want developers to incorporate security analysis into their daily routines.

A robust finding-suppression mechanism to prevent false positives from reoccurring once you’ve verified them as a non-issue.

Ability to easily define additional rules so the tool can enforce internal coding policies.

A centralized reporting component if you have a large team of developers and managers who want access to findings, trending and overview reporting

The post Source code analysis tools: Evaluation criteria appeared first on scmGalaxy.

Performance Optimization Checklist of Build Servers

Build Infrastructure Level

1.  Do you really need to build all source code or only the part of code which has changes?

2. Project should be divided into multiple modules/component which can be build independently and should be integrated when it needed.

3. Understand technology and make use of performance related features which will help you. e.g make, visual studio and maven has some feature which help us to compile only code which was changed also, some performance tuning features should be explored.

4. Compile dependent project only there are changes. no need to compile all the time.

5. Distribute application in non-compiled and to be compiled files. e.g src, docs and copy only src to comile. docs files cane be used while creating installer.

6. Plan for disk usage growth upfront.

Application Server level

1. Apache Server optimization and proper log setting
2. Disabling unused modules and component which will help performance.
3. Follow best practices of Module Configuration, Apache Server Configuration etc

 System level

1. Check if any background task/services is running which is consuming cpu/memory and can be  stopped and not relevant.
2. Keep system uptodate
3. Avoid using build server for any other task – If you must edit components or install software, build or edit the components on another machine and copy them over.
4. Use high speen drive for i/o operations

Build Server application level

http://www.cloudbees.com/sites/default/files/whitepapers/7WaysToOptimizeJenkins.pdf

1. Keep log files maintenance and truncate regularly. have limited build records.
2. Move build to document server. not to keep in build server
3. Take advantage of distribute build server using agents/slaves/nodes etc

The post Performance Optimization of Build Server | Performance Optimization Guide appeared first on scmGalaxy.

iostat reports CPU, disk I/O, and NFS statistics.

mpstat reports processors statictics.
vmstat reports virtual memory statistics.

vxstat – This Utility can be used as well.

iostat reports CPU, disk I/O, and NFS statistics.

The iostat command generates two types of reports, the CPU Utilization report and the Device Utilization report. The first report generated by the iostat command is the CPU Utilization Report.

The report has the following format:

%user – Show the percentage of CPU utilization that occurred while executing at the user level (application).
%nice – provides statistics on a per physical device or partition basis.
Device – This column gives the device name
tps – Indicate the number of transfers per second that were issued to the device. A transfer is an I/O request to the device.
Blk_read/s – Indicate the amount of data read from the drive expressed in a number of blocks per second.
Blk_wrtn/s – Indicate the amount of data written to the drive expressed in a number of blocks per second.
Blk_read – The total number of blocks read.
Blk_wrtn – The total number of blocks written.
kB_read/s – Indicate the amount of data read from the drive expressed in kilobytes per second.
kB_wrtn/s – Indicate the amount of data written to the drive expressed in kilobytes per second.
wrqm/s – The number of write requests merged per second that were issued to the device.
r/s – The number of read requests that were issued to the device per second.
w/s – The number of write requests that were issued to the device per second.
rsec/s – The number of sectors read from the device per second.
wsec/s – The number of sectors written to the device per second.
await – The average time (in milliseconds) for I/O requests issued to the device to be served.
svctm – The average service time (in milliseconds) for I/O requests that were issued to the device.
%util – Percentage of CPU time during which I/O requests were issued to the device.

vmstat reports virtual memory statistics.

The report has the following format:

Procs – r: Total number of processes waiting to run
Procs – b: Total number of busy processes
Memory – swpd: Used virtual memory
Memory – free: Free virtual memory
Memory – buff: Memory used as buffers
Memory – cache: Memory used as cache.
Swap – si: Memory swapped from disk (for every second)
Swap – so: Memory swapped to disk (for every second)
IO – bi: Blocks in. i.e blocks received from device (for every second)
IO – bo: Blocks out. i.e blocks sent to the device (for every second)
System – in: Interrupts per second
System – cs: Context switches
CPU – us, sy, id, wa, st: CPU user time, system time, idle time, wait time

mpstat reports processors statictics.

reports processors statictics(mpstat – Report processors related statistics and mpstat displays CPU statistics )

mpstat :- mpstat displays CPU statistics
mpstat -A :- Display all information
mpstat -P ALL :- Display CPU statistics of individual CPU (or) Core

Reference:
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=iostat
http://www.thegeekstuff.com/2011/07/iostat-vmstat-mpstat-examples/

The post Linux Performance Monitoring using iostat, mpstat and vmstat | Linux Performance Monitoring Guide appeared first on scmGalaxy.