The document provides an overview of high performance computing (HPC) systems and how to interact with them. It describes what HPC systems are, including their architecture using many nodes connected by high-speed networks. It also reviews the Stampede2 supercomputer specifications and demonstrates how to log in, move around the file systems, submit jobs using sbatch, and write simple serial and parallel programs using MPI.
The document provides instructions for interacting with and submitting jobs to a high performance computing (HPC) system. It begins by demonstrating how to log in to the system using SSH and describes the information displayed upon login. It then shows how to create and edit files using nano, run code interactively on a node using idev, and submit batch jobs using SLURM. The user creates Python scripts to print "Hello World" sequentially and in parallel, runs them interactively, and submits the parallel version as a batch job to demonstrate these workflows. Monitoring and management commands like squeue and scancel are also introduced.
Presented at LISA18: https://www.usenix.org/conference/lisa18/presentation/babrou
This is a technical dive into how we used eBPF to solve real-world issues uncovered during an innocent OS upgrade. We'll see how we debugged 10x CPU increase in Kafka after Debian upgrade and what lessons we learned. We'll get from high-level effects like increased CPU to flamegraphs showing us where the problem lies to tracing timers and functions calls in the Linux kernel.
The focus is on tools what operational engineers can use to debug performance issues in production. This particular issue happened at Cloudflare on a Kafka cluster doing 100Gbps of ingress and many multiple of that egress.
Linux Tracing Superpowers by Eugene PirogovPivorak MeetUp
This document discusses Linux tracing tools and the evolution from DTrace on BSD to eBPF on Linux. It begins with an overview of DTrace and its capabilities on BSD, then discusses the limitations of early Linux tracing tools. It introduces eBPF and the BCC compiler collection, which make it easier to write and use eBPF programs. Examples are given showing how BCC can be used to trace system calls, file opens, and command executions. The document argues that BCC and eBPF help address the problems of early Linux tracing by making the tools more approachable and powerful for production use.
OSSNA 2017 Performance Analysis Superpowers with Linux BPFBrendan Gregg
Talk by Brendan Gregg for OSSNA 2017. "Advanced performance observability and debugging have arrived built into the Linux 4.x series, thanks to enhancements to Berkeley Packet Filter (BPF, or eBPF) and the repurposing of its sandboxed virtual machine to provide programmatic capabilities to system tracing. Netflix has been investigating its use for new observability tools, monitoring, security uses, and more. This talk will be a dive deep on these new tracing, observability, and debugging capabilities, which sooner or later will be available to everyone who uses Linux. Whether you’re doing analysis over an ssh session, or via a monitoring GUI, BPF can be used to provide an efficient, custom, and deep level of detail into system and application performance.
This talk will also demonstrate the new open source tools that have been developed, which make use of kernel- and user-level dynamic tracing (kprobes and uprobes), and kernel- and user-level static tracing (tracepoints). These tools provide new insights for file system and storage performance, CPU scheduler performance, TCP performance, and a whole lot more. This is a major turning point for Linux systems engineering, as custom advanced performance instrumentation can be used safely in production environments, powering a new generation of tools and visualizations."
Delivered as plenary at USENIX LISA 2013. video here: https://www.youtube.com/watch?v=nZfNehCzGdw and https://www.usenix.org/conference/lisa13/technical-sessions/plenary/gregg . "How did we ever analyze performance before Flame Graphs?" This new visualization invented by Brendan can help you quickly understand application and kernel performance, especially CPU usage, where stacks (call graphs) can be sampled and then visualized as an interactive flame graph. Flame Graphs are now used for a growing variety of targets: for applications and kernels on Linux, SmartOS, Mac OS X, and Windows; for languages including C, C++, node.js, ruby, and Lua; and in WebKit Web Inspector. This talk will explain them and provide use cases and new visualizations for other event types, including I/O, memory usage, and latency.
Kernel Recipes 2017 - Understanding the Linux kernel via ftrace - Steven RostedtAnne Nicolas
Ftrace is the official tracer of the Linux kernel. It has been apart of Linux since 2.6.31, and has grown tremendously ever since. Ftrace’s name comes from its most powerful feature: function tracing. But the ftrace infrastructure is much more than that. It also encompasses the trace events that are used by perf, as well as kprobes that can dynamically add trace events that the user defines.
This talk will focus on learning how the kernel works by using the ftrace infrastructure. It will show how to see what happens within the kernel during a system call; learn how interrupts work; see how ones processes are being scheduled, and more. A quick introduction to some tools like trace-cmd and KernelShark will also be demonstrated.
Steven Rostedt, VMware
LISA18: Hidden Linux Metrics with Prometheus eBPF ExporterIvan Babrou
Presented at LISA18: https://www.usenix.org/conference/lisa18/presentation/huynh
While there are plenty of readily available metrics for monitoring Linux kernel, many gems remain hidden. With the help of recent developments in eBPF, it is now possible to run safe programs in the kernel to collect arbitrary information with little to no overhead. A few examples include:
* Disk latency and io size histograms
* Run queue (scheduler) latency
* Page cache efficiency
* Directory cache efficiency
* LLC (aka L3 cache) efficiency
* Kernel timer counters
* System-wide TCP retransmits
Practically any event from "perf list" output and any kernel function can be traced, analyzed and turned into a Prometheus metric with almost arbitrary labels attached to it.
If you are already familiar with BCC tools, you may think if ebpf_exporter as bcc tools turned into prometheus metrics.
In this tutorial we’ll go over eBPF basics, how to write programs and get insights into a running system.
The document provides instructions for interacting with and submitting jobs to a high performance computing (HPC) system. It begins by demonstrating how to log in to the system using SSH and describes the information displayed upon login. It then shows how to create and edit files using nano, run code interactively on a node using idev, and submit batch jobs using SLURM. The user creates Python scripts to print "Hello World" sequentially and in parallel, runs them interactively, and submits the parallel version as a batch job to demonstrate these workflows. Monitoring and management commands like squeue and scancel are also introduced.
Presented at LISA18: https://www.usenix.org/conference/lisa18/presentation/babrou
This is a technical dive into how we used eBPF to solve real-world issues uncovered during an innocent OS upgrade. We'll see how we debugged 10x CPU increase in Kafka after Debian upgrade and what lessons we learned. We'll get from high-level effects like increased CPU to flamegraphs showing us where the problem lies to tracing timers and functions calls in the Linux kernel.
The focus is on tools what operational engineers can use to debug performance issues in production. This particular issue happened at Cloudflare on a Kafka cluster doing 100Gbps of ingress and many multiple of that egress.
Linux Tracing Superpowers by Eugene PirogovPivorak MeetUp
This document discusses Linux tracing tools and the evolution from DTrace on BSD to eBPF on Linux. It begins with an overview of DTrace and its capabilities on BSD, then discusses the limitations of early Linux tracing tools. It introduces eBPF and the BCC compiler collection, which make it easier to write and use eBPF programs. Examples are given showing how BCC can be used to trace system calls, file opens, and command executions. The document argues that BCC and eBPF help address the problems of early Linux tracing by making the tools more approachable and powerful for production use.
OSSNA 2017 Performance Analysis Superpowers with Linux BPFBrendan Gregg
Talk by Brendan Gregg for OSSNA 2017. "Advanced performance observability and debugging have arrived built into the Linux 4.x series, thanks to enhancements to Berkeley Packet Filter (BPF, or eBPF) and the repurposing of its sandboxed virtual machine to provide programmatic capabilities to system tracing. Netflix has been investigating its use for new observability tools, monitoring, security uses, and more. This talk will be a dive deep on these new tracing, observability, and debugging capabilities, which sooner or later will be available to everyone who uses Linux. Whether you’re doing analysis over an ssh session, or via a monitoring GUI, BPF can be used to provide an efficient, custom, and deep level of detail into system and application performance.
This talk will also demonstrate the new open source tools that have been developed, which make use of kernel- and user-level dynamic tracing (kprobes and uprobes), and kernel- and user-level static tracing (tracepoints). These tools provide new insights for file system and storage performance, CPU scheduler performance, TCP performance, and a whole lot more. This is a major turning point for Linux systems engineering, as custom advanced performance instrumentation can be used safely in production environments, powering a new generation of tools and visualizations."
Delivered as plenary at USENIX LISA 2013. video here: https://www.youtube.com/watch?v=nZfNehCzGdw and https://www.usenix.org/conference/lisa13/technical-sessions/plenary/gregg . "How did we ever analyze performance before Flame Graphs?" This new visualization invented by Brendan can help you quickly understand application and kernel performance, especially CPU usage, where stacks (call graphs) can be sampled and then visualized as an interactive flame graph. Flame Graphs are now used for a growing variety of targets: for applications and kernels on Linux, SmartOS, Mac OS X, and Windows; for languages including C, C++, node.js, ruby, and Lua; and in WebKit Web Inspector. This talk will explain them and provide use cases and new visualizations for other event types, including I/O, memory usage, and latency.
Kernel Recipes 2017 - Understanding the Linux kernel via ftrace - Steven RostedtAnne Nicolas
Ftrace is the official tracer of the Linux kernel. It has been apart of Linux since 2.6.31, and has grown tremendously ever since. Ftrace’s name comes from its most powerful feature: function tracing. But the ftrace infrastructure is much more than that. It also encompasses the trace events that are used by perf, as well as kprobes that can dynamically add trace events that the user defines.
This talk will focus on learning how the kernel works by using the ftrace infrastructure. It will show how to see what happens within the kernel during a system call; learn how interrupts work; see how ones processes are being scheduled, and more. A quick introduction to some tools like trace-cmd and KernelShark will also be demonstrated.
Steven Rostedt, VMware
LISA18: Hidden Linux Metrics with Prometheus eBPF ExporterIvan Babrou
Presented at LISA18: https://www.usenix.org/conference/lisa18/presentation/huynh
While there are plenty of readily available metrics for monitoring Linux kernel, many gems remain hidden. With the help of recent developments in eBPF, it is now possible to run safe programs in the kernel to collect arbitrary information with little to no overhead. A few examples include:
* Disk latency and io size histograms
* Run queue (scheduler) latency
* Page cache efficiency
* Directory cache efficiency
* LLC (aka L3 cache) efficiency
* Kernel timer counters
* System-wide TCP retransmits
Practically any event from "perf list" output and any kernel function can be traced, analyzed and turned into a Prometheus metric with almost arbitrary labels attached to it.
If you are already familiar with BCC tools, you may think if ebpf_exporter as bcc tools turned into prometheus metrics.
In this tutorial we’ll go over eBPF basics, how to write programs and get insights into a running system.
Talk for Facebook Systems@Scale 2021 by Brendan Gregg: "BPF (eBPF) tracing is the superpower that can analyze everything, helping you find performance wins, troubleshoot software, and more. But with many different front-ends and languages, and years of evolution, finding the right starting point can be hard. This talk will make it easy, showing how to install and run selected BPF tools in the bcc and bpftrace open source projects for some quick wins. Think like a sysadmin, not like a programmer."
Raul Leite discusses several key NFV concepts and bottlenecks including:
1) NFV architecture which aims for independent hardware, automatic network operation, and flexible application development.
2) Common NFV bottlenecks like packet loss, hypervisor overhead, and low throughput due to CPU and resource allocation issues.
3) Techniques to optimize NFV performance such as SR-IOV, PCI passthrough, hugepages, CPU pinning, and DPDK. SR-IOV and PCI passthrough provide direct access to network hardware while hugepages, pinning and DPDK improve CPU performance.
Velocity 2017 Performance analysis superpowers with Linux eBPFBrendan Gregg
Talk by for Velocity 2017 by Brendan Gregg: Performance analysis superpowers with Linux eBPF.
"Advanced performance observability and debugging have arrived built into the Linux 4.x series, thanks to enhancements to Berkeley Packet Filter (BPF, or eBPF) and the repurposing of its sandboxed virtual machine to provide programmatic capabilities to system tracing. Netflix has been investigating its use for new observability tools, monitoring, security uses, and more. This talk will investigate this new technology, which sooner or later will be available to everyone who uses Linux. The talk will dive deep on these new tracing, observability, and debugging capabilities. Whether you’re doing analysis over an ssh session, or via a monitoring GUI, BPF can be used to provide an efficient, custom, and deep level of detail into system and application performance.
This talk will also demonstrate the new open source tools that have been developed, which make use of kernel- and user-level dynamic tracing (kprobes and uprobes), and kernel- and user-level static tracing (tracepoints). These tools provide new insights for file system and storage performance, CPU scheduler performance, TCP performance, and a whole lot more. This is a major turning point for Linux systems engineering, as custom advanced performance instrumentation can be used safely in production environments, powering a new generation of tools and visualizations."
The document discusses analyzing Linux kernel crash dumps. It covers various ways to gather crash data like serial console, netconsole, kmsg dumpers, Kdump, and Pstore. It then discusses analyzing the crashed kernel using tools like ksymoops, crash utility, and examining the backtrace, kernel logs, processes, and file descriptors. The document provides examples of gathering data from Pstore and using commands like bt, log, and ps with the crash utility to extract information from a crash dump.
When your whole system is unresponsive, how to investigate on this failure ?
We'll see how to get a memory dump for offline analysis with kdump system.
Then how to analyze it with crash utility.
And finally, how to use crash on a running system to modify the kernel memory (at your own risks !)
This document describes migrating a database from a standalone MySQL configuration to a Galera cluster for high availability and redundancy. It outlines the existing infrastructure including web, mail, and database servers managed by Puppet. It then details removing the existing MySQL data and joining the nodes to the new Galera cluster. Configuration files are shown for Galera settings like the state snapshot transfer method and slave threads. System information is displayed for one of the Galera nodes including the large production database size and high query throughput. The GitHub link shows example Puppet code to check the Galera cluster status and return errors if not in the primary or connected states.
The document discusses diagnosing and mitigating MySQL performance issues. It describes using various operating system monitoring tools like vmstat, iostat, and top to analyze CPU, memory, disk, and network utilization. It also discusses using MySQL-specific tools like the MySQL command line, mysqladmin, mysqlbinlog, and external tools to diagnose issues like high load, I/O wait, or slow queries by examining metrics like queries, connections, storage engine statistics, and InnoDB logs and data written. The agenda covers identifying system and MySQL-specific bottlenecks by verifying OS metrics and running diagnostics on the database, storage engines, configuration, and queries.
This document provides an introduction to eBPF and XDP. It discusses the history of BPF and how it evolved into eBPF. Key aspects of eBPF covered include the instruction set, JIT compilation, verifier, helper functions, and maps. XDP is introduced as a way to program the data plane using eBPF programs attached early in the receive path. Example use cases and performance benchmarks for XDP are also mentioned.
Slides from the Linux Conference Australia 2021 conference https://linux.conf.au/schedule/presentation/64/ .
Tempesta TLS is an implementation of TLS handshakes for the Linux kernel. Since the kernel already provides symmetric ciphers, we focus on asymmetric cryptography only, elliptic curves in particular.
Use used the mbed TLS library as the foundation and almost fully rewrote it to make is x40 faster. During our development we also use parts of WolfSSL library. While WolfSSL outperforms OpenSSL, it uses the same algorithms, which are 5-7 years of old. Tempesta TLS uses newer and more efficient algorithms from the modern cryptography research.
While we still improving performance of Tempesta TLS, the implementation already establishes 40-80% more TLS handshakes per second than OpenSSL/Nginx and provides up to x4 lower latency in several tests.
This talk covers following topics with plenty of benchmarks:
* The fundamentals of elliptic curve computations and the most "hot spots"
* Side channel attacks (SCA) and methods to prevent them
* How the recent CPU vulnerabilities impact TLS handshakes
* Basics of the new fast algorithms used in the Tempesta TLS
* The design trade offs in OpenSSL, WolfSSL, mbed TLS, and Tempesta TLS
This document provides instructions for setting up a single server SDN testbed environment using Open vSwitch. It describes installing Ubuntu, configuring networking, installing necessary programs like Open vSwitch and DevStack, and configuring Open vSwitch bridges, tunnels, and virtual machines to emulate an SDN network on a single physical server.
LOPSA SD 2014.03.27 Presentation on Linux Performance Analysis
An introduction using the USE method and showing how several tools fit into those resource evaluations.
Debugging the Cloud Foundry Routing TierVMware Tanzu
The document describes an issue where Gorouters in Cloud Foundry are experiencing high memory usage, too many open files, and a growing number of connections from HAProxy load balancers to the Gorouters but not from the Gorouters to application backends. This suggests a problem with unclosed connections on the Gorouters. Various troubleshooting steps are described, such as checking Gorouter logs and metrics, restarting Gorouters, and ruling out misbehaving route services. However, the root cause is not definitively identified.
Talk for PerconaLive 2016 by Brendan Gregg. Video: https://www.youtube.com/watch?v=CbmEDXq7es0 . "Systems performance provides a different perspective for analysis and tuning, and can help you find performance wins for your databases, applications, and the kernel. However, most of us are not performance or kernel engineers, and have limited time to study this topic. This talk summarizes six important areas of Linux systems performance in 50 minutes: observability tools, methodologies, benchmarking, profiling, tracing, and tuning. Included are recipes for Linux performance analysis and tuning (using vmstat, mpstat, iostat, etc), overviews of complex areas including profiling (perf_events), static tracing (tracepoints), and dynamic tracing (kprobes, uprobes), and much advice about what is and isn't important to learn. This talk is aimed at everyone: DBAs, developers, operations, etc, and in any environment running Linux, bare-metal or the cloud."
Kernel Recipes 2017: Performance Analysis with BPFBrendan Gregg
Talk by Brendan Gregg at Kernel Recipes 2017 (Paris): "The in-kernel Berkeley Packet Filter (BPF) has been enhanced in recent kernels to do much more than just filtering packets. It can now run user-defined programs on events, such as on tracepoints, kprobes, uprobes, and perf_events, allowing advanced performance analysis tools to be created. These can be used in production as the BPF virtual machine is sandboxed and will reject unsafe code, and are already in use at Netflix.
Beginning with the bpf() syscall in 3.18, enhancements have been added in many kernel versions since, with major features for BPF analysis landing in Linux 4.1, 4.4, 4.7, and 4.9. Specific capabilities these provide include custom in-kernel summaries of metrics, custom latency measurements, and frequency counting kernel and user stack traces on events. One interesting case involves saving stack traces on wake up events, and associating them with the blocked stack trace: so that we can see the blocking stack trace and the waker together, merged in kernel by a BPF program (that particular example is in the kernel as samples/bpf/offwaketime).
This talk will discuss the new BPF capabilities for performance analysis and debugging, and demonstrate the new open source tools that have been developed to use it, many of which are in the Linux Foundation iovisor bcc (BPF Compiler Collection) project. These include tools to analyze the CPU scheduler, TCP performance, file system performance, block I/O, and more."
This document discusses using Oracle Database's block change tracking and direct NFS features to enable fast cloning of databases for development and testing purposes at low cost. Block change tracking allows incremental backups to be performed quickly, while direct NFS allows database files to be copied over the network efficiently to create clones that only require storage for changed blocks. Examples are provided demonstrating how this can be used to regularly clone a production database to multiple developer environments.
The document evaluates Lustre 2.9 and OpenStack for providing isolated POSIX file systems to tenants in OpenStack, finding that Lustre 2.9 allows uid mapping that can isolate tenants while maintaining high performance, and that physical and virtual Lustre routers can route traffic between tenants effectively albeit with some increased east-west traffic with virtual routers.
The document summarizes a talk on container performance analysis. It discusses identifying bottlenecks at the host, container, and kernel level using various Linux performance tools. It then provides an overview of how containers work in Linux using namespaces and control groups (cgroups). Finally, it demonstrates some example commands like docker stats, systemd-cgtop, and bcc/BPF tools that can be used to analyze containers and cgroups from the host system.
The document discusses new features in MySQL 5.6 replication including:
1) Crash-safe slaves that store replication information in database tables to prevent data loss if slaves crash.
2) Multi-threaded slaves that improve performance by distributing the replication workload across multiple threads.
3) Time-delayed replication that allows replication to be delayed by a configurable number of seconds.
4) Optimized row-based replication that reduces the size of binary logs by only replicating changed columns where possible.
This document discusses monitoring and capacity planning on a consolidated environment. It begins with comparing CPU speeds using benchmarks like TPC-C and SPECint_rate2006 or tools like cputoolkit and SLOB. It then covers cores vs threads, explaining how hyper-threading can increase performance by around 30%. Different CPU events like CPU utilization, wait, and scheduling are also explained. Finally, it discusses monitoring CPU usage on consolidated environments using operating system tools like vmstat, top, and mpstat.
Perf is a Linux profiler tool that uses performance monitoring hardware to count various events like CPU cycles, instructions, and cache misses. It can count events for a single thread, entire process, specific CPUs, or system-wide. Perf stat is used to count events during process execution, while perf record collects profiling data in a file for later analysis with perf report.
Trends in Systems and How to Get Efficient Performanceinside-BigData.com
In this video from Switzerland HPC Conference, Martin Hilgeman from Dell presents: HPC Workload Efficiency and the Challenges for System Builders.
"With all the advances in massively parallel and multi-core computing with CPUs and accelerators it is often overlooked whether the computational work is being done in an efficient manner. This efficiency is largely being determined at the application level and therefore puts the responsibility of sustaining a certain performance trajectory into the hands of the user. It is observed that the adoption rate of new hardware capabilities is decreasing and lead to a feeling of diminishing returns. This presentation shows the well-known laws of parallel performance from the perspective of a system builder. It also covers through the use of real case studies, examples of how to program for energy efficient parallel application performance."
Watch the video: http://wp.me/p3RLHQ-gIS
Learn more: http://dell.com
and
http://www.hpcadvisorycouncil.com/events/2017/swiss-workshop/agenda.php
Sign up for our insideHPC Newsletter: http://insidehpc.com/newsletter
This presentation recounts the story of Macys.com and Bloomingdales.com's migration from legacy RDBMS to NoSQL Cassandra in partnership with DataStax.
One thing that differentiates this talk from others on Cassandra is Macy's philosophy of "doing more with less." You will see why we emphasize the performance tuning aspects of iterative development when you see how much processing we can support on relatively small configurations.
This session will cover:
1) The process that led to our decision to use Cassandra
2) The approach we used for migrating from DB2 & Coherence to Cassandra without disrupting the production environment
3) The various schema options that we tried and how we settled on the current one. We'll show you a selection of some of our extensive performance tuning benchmarks, as well as how these performance results figured into our final schema designs.
4) Our lessons learned and next steps
Talk for Facebook Systems@Scale 2021 by Brendan Gregg: "BPF (eBPF) tracing is the superpower that can analyze everything, helping you find performance wins, troubleshoot software, and more. But with many different front-ends and languages, and years of evolution, finding the right starting point can be hard. This talk will make it easy, showing how to install and run selected BPF tools in the bcc and bpftrace open source projects for some quick wins. Think like a sysadmin, not like a programmer."
Raul Leite discusses several key NFV concepts and bottlenecks including:
1) NFV architecture which aims for independent hardware, automatic network operation, and flexible application development.
2) Common NFV bottlenecks like packet loss, hypervisor overhead, and low throughput due to CPU and resource allocation issues.
3) Techniques to optimize NFV performance such as SR-IOV, PCI passthrough, hugepages, CPU pinning, and DPDK. SR-IOV and PCI passthrough provide direct access to network hardware while hugepages, pinning and DPDK improve CPU performance.
Velocity 2017 Performance analysis superpowers with Linux eBPFBrendan Gregg
Talk by for Velocity 2017 by Brendan Gregg: Performance analysis superpowers with Linux eBPF.
"Advanced performance observability and debugging have arrived built into the Linux 4.x series, thanks to enhancements to Berkeley Packet Filter (BPF, or eBPF) and the repurposing of its sandboxed virtual machine to provide programmatic capabilities to system tracing. Netflix has been investigating its use for new observability tools, monitoring, security uses, and more. This talk will investigate this new technology, which sooner or later will be available to everyone who uses Linux. The talk will dive deep on these new tracing, observability, and debugging capabilities. Whether you’re doing analysis over an ssh session, or via a monitoring GUI, BPF can be used to provide an efficient, custom, and deep level of detail into system and application performance.
This talk will also demonstrate the new open source tools that have been developed, which make use of kernel- and user-level dynamic tracing (kprobes and uprobes), and kernel- and user-level static tracing (tracepoints). These tools provide new insights for file system and storage performance, CPU scheduler performance, TCP performance, and a whole lot more. This is a major turning point for Linux systems engineering, as custom advanced performance instrumentation can be used safely in production environments, powering a new generation of tools and visualizations."
The document discusses analyzing Linux kernel crash dumps. It covers various ways to gather crash data like serial console, netconsole, kmsg dumpers, Kdump, and Pstore. It then discusses analyzing the crashed kernel using tools like ksymoops, crash utility, and examining the backtrace, kernel logs, processes, and file descriptors. The document provides examples of gathering data from Pstore and using commands like bt, log, and ps with the crash utility to extract information from a crash dump.
When your whole system is unresponsive, how to investigate on this failure ?
We'll see how to get a memory dump for offline analysis with kdump system.
Then how to analyze it with crash utility.
And finally, how to use crash on a running system to modify the kernel memory (at your own risks !)
This document describes migrating a database from a standalone MySQL configuration to a Galera cluster for high availability and redundancy. It outlines the existing infrastructure including web, mail, and database servers managed by Puppet. It then details removing the existing MySQL data and joining the nodes to the new Galera cluster. Configuration files are shown for Galera settings like the state snapshot transfer method and slave threads. System information is displayed for one of the Galera nodes including the large production database size and high query throughput. The GitHub link shows example Puppet code to check the Galera cluster status and return errors if not in the primary or connected states.
The document discusses diagnosing and mitigating MySQL performance issues. It describes using various operating system monitoring tools like vmstat, iostat, and top to analyze CPU, memory, disk, and network utilization. It also discusses using MySQL-specific tools like the MySQL command line, mysqladmin, mysqlbinlog, and external tools to diagnose issues like high load, I/O wait, or slow queries by examining metrics like queries, connections, storage engine statistics, and InnoDB logs and data written. The agenda covers identifying system and MySQL-specific bottlenecks by verifying OS metrics and running diagnostics on the database, storage engines, configuration, and queries.
This document provides an introduction to eBPF and XDP. It discusses the history of BPF and how it evolved into eBPF. Key aspects of eBPF covered include the instruction set, JIT compilation, verifier, helper functions, and maps. XDP is introduced as a way to program the data plane using eBPF programs attached early in the receive path. Example use cases and performance benchmarks for XDP are also mentioned.
Slides from the Linux Conference Australia 2021 conference https://linux.conf.au/schedule/presentation/64/ .
Tempesta TLS is an implementation of TLS handshakes for the Linux kernel. Since the kernel already provides symmetric ciphers, we focus on asymmetric cryptography only, elliptic curves in particular.
Use used the mbed TLS library as the foundation and almost fully rewrote it to make is x40 faster. During our development we also use parts of WolfSSL library. While WolfSSL outperforms OpenSSL, it uses the same algorithms, which are 5-7 years of old. Tempesta TLS uses newer and more efficient algorithms from the modern cryptography research.
While we still improving performance of Tempesta TLS, the implementation already establishes 40-80% more TLS handshakes per second than OpenSSL/Nginx and provides up to x4 lower latency in several tests.
This talk covers following topics with plenty of benchmarks:
* The fundamentals of elliptic curve computations and the most "hot spots"
* Side channel attacks (SCA) and methods to prevent them
* How the recent CPU vulnerabilities impact TLS handshakes
* Basics of the new fast algorithms used in the Tempesta TLS
* The design trade offs in OpenSSL, WolfSSL, mbed TLS, and Tempesta TLS
This document provides instructions for setting up a single server SDN testbed environment using Open vSwitch. It describes installing Ubuntu, configuring networking, installing necessary programs like Open vSwitch and DevStack, and configuring Open vSwitch bridges, tunnels, and virtual machines to emulate an SDN network on a single physical server.
LOPSA SD 2014.03.27 Presentation on Linux Performance Analysis
An introduction using the USE method and showing how several tools fit into those resource evaluations.
Debugging the Cloud Foundry Routing TierVMware Tanzu
The document describes an issue where Gorouters in Cloud Foundry are experiencing high memory usage, too many open files, and a growing number of connections from HAProxy load balancers to the Gorouters but not from the Gorouters to application backends. This suggests a problem with unclosed connections on the Gorouters. Various troubleshooting steps are described, such as checking Gorouter logs and metrics, restarting Gorouters, and ruling out misbehaving route services. However, the root cause is not definitively identified.
Talk for PerconaLive 2016 by Brendan Gregg. Video: https://www.youtube.com/watch?v=CbmEDXq7es0 . "Systems performance provides a different perspective for analysis and tuning, and can help you find performance wins for your databases, applications, and the kernel. However, most of us are not performance or kernel engineers, and have limited time to study this topic. This talk summarizes six important areas of Linux systems performance in 50 minutes: observability tools, methodologies, benchmarking, profiling, tracing, and tuning. Included are recipes for Linux performance analysis and tuning (using vmstat, mpstat, iostat, etc), overviews of complex areas including profiling (perf_events), static tracing (tracepoints), and dynamic tracing (kprobes, uprobes), and much advice about what is and isn't important to learn. This talk is aimed at everyone: DBAs, developers, operations, etc, and in any environment running Linux, bare-metal or the cloud."
Kernel Recipes 2017: Performance Analysis with BPFBrendan Gregg
Talk by Brendan Gregg at Kernel Recipes 2017 (Paris): "The in-kernel Berkeley Packet Filter (BPF) has been enhanced in recent kernels to do much more than just filtering packets. It can now run user-defined programs on events, such as on tracepoints, kprobes, uprobes, and perf_events, allowing advanced performance analysis tools to be created. These can be used in production as the BPF virtual machine is sandboxed and will reject unsafe code, and are already in use at Netflix.
Beginning with the bpf() syscall in 3.18, enhancements have been added in many kernel versions since, with major features for BPF analysis landing in Linux 4.1, 4.4, 4.7, and 4.9. Specific capabilities these provide include custom in-kernel summaries of metrics, custom latency measurements, and frequency counting kernel and user stack traces on events. One interesting case involves saving stack traces on wake up events, and associating them with the blocked stack trace: so that we can see the blocking stack trace and the waker together, merged in kernel by a BPF program (that particular example is in the kernel as samples/bpf/offwaketime).
This talk will discuss the new BPF capabilities for performance analysis and debugging, and demonstrate the new open source tools that have been developed to use it, many of which are in the Linux Foundation iovisor bcc (BPF Compiler Collection) project. These include tools to analyze the CPU scheduler, TCP performance, file system performance, block I/O, and more."
This document discusses using Oracle Database's block change tracking and direct NFS features to enable fast cloning of databases for development and testing purposes at low cost. Block change tracking allows incremental backups to be performed quickly, while direct NFS allows database files to be copied over the network efficiently to create clones that only require storage for changed blocks. Examples are provided demonstrating how this can be used to regularly clone a production database to multiple developer environments.
The document evaluates Lustre 2.9 and OpenStack for providing isolated POSIX file systems to tenants in OpenStack, finding that Lustre 2.9 allows uid mapping that can isolate tenants while maintaining high performance, and that physical and virtual Lustre routers can route traffic between tenants effectively albeit with some increased east-west traffic with virtual routers.
The document summarizes a talk on container performance analysis. It discusses identifying bottlenecks at the host, container, and kernel level using various Linux performance tools. It then provides an overview of how containers work in Linux using namespaces and control groups (cgroups). Finally, it demonstrates some example commands like docker stats, systemd-cgtop, and bcc/BPF tools that can be used to analyze containers and cgroups from the host system.
The document discusses new features in MySQL 5.6 replication including:
1) Crash-safe slaves that store replication information in database tables to prevent data loss if slaves crash.
2) Multi-threaded slaves that improve performance by distributing the replication workload across multiple threads.
3) Time-delayed replication that allows replication to be delayed by a configurable number of seconds.
4) Optimized row-based replication that reduces the size of binary logs by only replicating changed columns where possible.
This document discusses monitoring and capacity planning on a consolidated environment. It begins with comparing CPU speeds using benchmarks like TPC-C and SPECint_rate2006 or tools like cputoolkit and SLOB. It then covers cores vs threads, explaining how hyper-threading can increase performance by around 30%. Different CPU events like CPU utilization, wait, and scheduling are also explained. Finally, it discusses monitoring CPU usage on consolidated environments using operating system tools like vmstat, top, and mpstat.
Perf is a Linux profiler tool that uses performance monitoring hardware to count various events like CPU cycles, instructions, and cache misses. It can count events for a single thread, entire process, specific CPUs, or system-wide. Perf stat is used to count events during process execution, while perf record collects profiling data in a file for later analysis with perf report.
Trends in Systems and How to Get Efficient Performanceinside-BigData.com
In this video from Switzerland HPC Conference, Martin Hilgeman from Dell presents: HPC Workload Efficiency and the Challenges for System Builders.
"With all the advances in massively parallel and multi-core computing with CPUs and accelerators it is often overlooked whether the computational work is being done in an efficient manner. This efficiency is largely being determined at the application level and therefore puts the responsibility of sustaining a certain performance trajectory into the hands of the user. It is observed that the adoption rate of new hardware capabilities is decreasing and lead to a feeling of diminishing returns. This presentation shows the well-known laws of parallel performance from the perspective of a system builder. It also covers through the use of real case studies, examples of how to program for energy efficient parallel application performance."
Watch the video: http://wp.me/p3RLHQ-gIS
Learn more: http://dell.com
and
http://www.hpcadvisorycouncil.com/events/2017/swiss-workshop/agenda.php
Sign up for our insideHPC Newsletter: http://insidehpc.com/newsletter
This presentation recounts the story of Macys.com and Bloomingdales.com's migration from legacy RDBMS to NoSQL Cassandra in partnership with DataStax.
One thing that differentiates this talk from others on Cassandra is Macy's philosophy of "doing more with less." You will see why we emphasize the performance tuning aspects of iterative development when you see how much processing we can support on relatively small configurations.
This session will cover:
1) The process that led to our decision to use Cassandra
2) The approach we used for migrating from DB2 & Coherence to Cassandra without disrupting the production environment
3) The various schema options that we tried and how we settled on the current one. We'll show you a selection of some of our extensive performance tuning benchmarks, as well as how these performance results figured into our final schema designs.
4) Our lessons learned and next steps
Analyzing OS X Systems Performance with the USE MethodBrendan Gregg
Talk for MacIT 2014. This talk is about systems performance on OS X, and introduces the USE Method to check for common performance bottlenecks and errors. This methodology can be used by beginners and experts alike, and begins by constructing a checklist of the questions we’d like to ask of the system, before reaching for tools to answer them. The focus is resources: CPUs, GPUs, memory capacity, network interfaces, storage devices, controllers, interconnects, as well as some software resources such as mutex locks. These areas are investigated by a wide variety of tools, including vm_stat, iostat, netstat, top, latency, the DTrace scripts in /usr/bin (which were written by Brendan), custom DTrace scripts, Instruments, and more. This is a tour of the tools needed to solve our performance needs, rather than understanding tools just because they exist. This talk will make you aware of many areas of OS X that you can investigate, which will be especially useful for the time when you need to get to the bottom of a performance issue.
One of the great challenges of of monitoring any large cluster is how much data to collect and how often to collect it. Those responsible for managing the cloud infrastructure want to see everything collected centrally which places limits on how much and how often. Developers on the other hand want to see as much detail as they can at as high a frequency as reasonable without impacting the overall cloud performance.
To address what seems to be conflicting requirements, we've chosen a hybrid model at HP. Like many others, we have a centralized monitoring system that records a set of key system metrics for all servers at the granularity of 1 minute, but at the same time we do fine-grained local monitoring on each server of hundreds of metrics every second so when there are problems that need more details than are available centrally, one can go to the servers in question to see exactly what was going on at any specific time.
The tool of choice for this fine-grained monitoring is the open source tool collectl, which additionally has an extensible api. It is through this api that we've developed a swift monitoring capability to not only capture the number of gets, put, etc every second, but using collectl's colmux utility, we can also display these in a top-like formact to see exactly what all the object and/or proxy servers are doing in real-time.
We've also developer a second cability that allows one to see what the Virtual Machines are doing on each compute node in terms of CPU, disk and network traffic. This data can also be displayed in real-time with colmux.
This talk will briefly introduce the audience to collectl's capabilities but more importantly show how it's used to augment any existing centralized monitoring infrastructure.
Speakers
Mark Seger
uCluster (micro-Cluster) is a toy computer cluster composed of 3 Raspberry Pi boards, 2 NVIDIA Jetson Nano boards and 1 NVIDIA Jetson TX2 board.
The presentation shows how to build the uCluster and focuses on few interesting technologies for further consideration when building a cluster at any scale.
The project is for educational purposes and tinkering with various technologies.
TRex is an open source, low cost, stateful traffic generator fuelled by DPDK. It generates L4-7 traffic based on pre-processing and a smart replay of real traffic templates. TRex amplifies both client and server side traffic and can scale to 200Gb/sec with one UCS.
Clear Containers is an Open Containers Initiative (OCI) “runtime” that launches an Intel VT-x secured hypervisor rather than a standard Linux container. An introduction of Clear Containers will be provided, followed by an overview of CNM networking plugins which have been created to enhance network connectivity using Clear Containers. More specifically, we will show demonstrations of using VPP with DPDK and SRIO-v based networks to connect Clear Containers. Pending time we will provide and walk through a hands on example of using VPP with Clear Containers.
About the speaker: Manohar Castelino is a Principal Engineer for Intel’s Open Source Technology Center. Manohar has worked on networking, network management, network processors and virtualization for over 15 years. Manohar is currently an architect and developer with the ciao (clearlinux.org/ciao) and the clear containers (https://github.com/01org/cc-oci-runtime) projects focused on networking. Manohar has spoken at many Container Meetups and internal conferences.
The document discusses using the sar (system activity reporter) utility to analyze I/O performance issues. Sar measures CPU, memory, and disk utilization over time. It was used to identify a bottleneck causing high I/O wait times in a payroll system. Sar reported redo log disks at 80-100% utilization. Upgrading an SRDF link from 2 to 4 links resolved the issue by improving redo log synchronization between disk arrays. The document provides steps for collecting sar data, loading it into a database, and graphing it to analyze system performance over time.
Troubleshooting Complex Performance issues - Oracle SEG$ contentionTanel Poder
From Tanel Poder's Troubleshooting Complex Performance Issues series - an example of Oracle SEG$ internal segment contention due to some direct path insert activity.
The document discusses CPU performance monitoring and capacity planning. It begins with an overview of different CPU events that can be monitored like CPU usage, CPU wait, and CPU scheduler. It then discusses various tools that can be used to monitor CPU usage on the operating system and database level. Finally, it covers methods to compare CPU speeds between different systems, including using published benchmarks and doing actual benchmarking with tools like cputoolkit.
This document provides an overview of Linux performance monitoring tools including mpstat, top, htop, vmstat, iostat, free, strace, and tcpdump. It discusses what each tool measures and how to use it to observe system performance and diagnose issues. The tools presented provide visibility into CPU usage, memory usage, disk I/O, network traffic, and system call activity which are essential for understanding workload performance on Linux systems.
Talk by Brendan Gregg for USENIX LISA 2019: Linux Systems Performance. Abstract: "
Systems performance is an effective discipline for performance analysis and tuning, and can help you find performance wins for your applications and the kernel. However, most of us are not performance or kernel engineers, and have limited time to study this topic. This talk summarizes the topic for everyone, touring six important areas of Linux systems performance: observability tools, methodologies, benchmarking, profiling, tracing, and tuning. Included are recipes for Linux performance analysis and tuning (using vmstat, mpstat, iostat, etc), overviews of complex areas including profiling (perf_events) and tracing (Ftrace, bcc/BPF, and bpftrace/BPF), and much advice about what is and isn't important to learn. This talk is aimed at everyone: developers, operations, sysadmins, etc, and in any environment running Linux, bare metal or the cloud."
OSDC 2017 - Werner Fischer - Linux performance profiling and monitoringNETWAYS
Nowadays system administrators have great choices when it comes down to Linux performance profiling and monitoring. The challenge is to pick the appropriate tools and interpret their results correctly.
This talk is a chance to take a tour through various performance profiling and benchmarking tools, focusing on their benefit for every sysadmin.
More than 25 different tools are presented. Ranging from well known tools like strace, iostat, tcpdump or vmstat to new features like Linux tracepoints or perf_events. You will also learn which tools can be monitored by Icinga and which monitoring plugins are already available for that.
At the end the goal is to gather reference points to look at, whenever you are faced with performance problems.
Take the chance to close your knowledge gaps and learn how to get the most out of your system.
Pythian is a global leader in database administration and consulting services. The document discusses the speaker's first 100 days of experience with an Oracle Exadata database machine. It provides an overview of Exadata components and features like Hybrid Columnar Compression and Smart Scan, which offloads processing from database servers to storage cells.
Design Considerations, Installation, and Commissioning of the RedRaider Cluster at the Texas Tech University
High Performance Computing Center
Outline of this talk
HPCC Staff and Students
Previous clusters
• History, Performance, usage Patterns, and Experience
Motivation for Upgrades
• Compute Capacity Goals
• Related Considerations
Installation and Benchmarks Conclusions and Q&A
This document summarizes an Informix Chat with the Lab session that covered various topics including educational seminars, technical presentations, database performance, disaster recovery, application development, security, Informix support, and a keynote on information as a service. It also announced an upcoming IIUG/IDUG conference in May 2007 in San Jose, California that would include calls for presentations.
This document provides an overview of CPU performance monitoring and capacity planning. It discusses how to compare CPU speeds using benchmarks like TPC-C and SPECint_rate2006. It also explains the difference between cores and threads, and reviews different CPU events that can be monitored like CPU utilization, wait time, and scheduling. The document demonstrates how to analyze CPU performance when migrating platforms and consolidating environments.
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Skybuffer AI: Advanced Conversational and Generative AI Solution on SAP Busin...Tatiana Kojar
Skybuffer AI, built on the robust SAP Business Technology Platform (SAP BTP), is the latest and most advanced version of our AI development, reaffirming our commitment to delivering top-tier AI solutions. Skybuffer AI harnesses all the innovative capabilities of the SAP BTP in the AI domain, from Conversational AI to cutting-edge Generative AI and Retrieval-Augmented Generation (RAG). It also helps SAP customers safeguard their investments into SAP Conversational AI and ensure a seamless, one-click transition to SAP Business AI.
With Skybuffer AI, various AI models can be integrated into a single communication channel such as Microsoft Teams. This integration empowers business users with insights drawn from SAP backend systems, enterprise documents, and the expansive knowledge of Generative AI. And the best part of it is that it is all managed through our intuitive no-code Action Server interface, requiring no extensive coding knowledge and making the advanced AI accessible to more users.
leewayhertz.com-AI in predictive maintenance Use cases technologies benefits ...alexjohnson7307
Predictive maintenance is a proactive approach that anticipates equipment failures before they happen. At the forefront of this innovative strategy is Artificial Intelligence (AI), which brings unprecedented precision and efficiency. AI in predictive maintenance is transforming industries by reducing downtime, minimizing costs, and enhancing productivity.
Trusted Execution Environment for Decentralized Process MiningLucaBarbaro3
Presentation of the paper "Trusted Execution Environment for Decentralized Process Mining" given during the CAiSE 2024 Conference in Cyprus on June 7, 2024.
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
1. PRESENTED BY:
Introduction to HPC
Interacting with High Performance
Computing Systems
6/7/18 1
Virginia Trueheart, MSIS
Texas Advanced Computing Center
vtrueheart@tacc.utexas.edu
2. An Overview of HPC: What is it?
High Performance Computing
• Parallel processing for advanced computation
• A “Supercomputer”, “Large Scale System”, or “Cluster”
The same parts as your laptop
• Processors, coprocessors, memory, operating system, etc.
• Specialized for scale & efficiency
Scale and Speed
• Thousands of nodes
• High bandwidth, low latency network for large scale I/O
6/7/18 2
3. An Overview of HPC: Stampede2
• Peak performance: 18 PF, rank 12 in Top 500 (2017)
• 4,200 68-core Knights Landing (KNL) nodes
• 1,736 48-core Skylake (SKX) nodes
• 368,928 cores and 736,512GB memory in total
• Interconnect: Intel’s Omni-Path Fabric Network
• Three Lustre Filesystems
• Funded by NSF through grant #ACI-1134872
6/7/18 3
4. An Overview of HPC: Architecture
6/7/18 4
idev
Internet
ssh
login
node
knl-
nodes
skx-
nodes
sbatch
omnipath
STAMPEDE 2
$HOME $WORK $SCRATCH
5. Ex: SKX Compute Node
6/7/18 5
Model Intel Xeon Platinum 8160 ("Skylake")
Cores Per Node 48 cores on two sockets (24 cores/socket)
Hardware Threads per
Core
2
Hardware Threads per
Node
96
Clock Rate 2.1Ghz
RAM 192GB
Cache 57MB per socket
Local Storage 144GB /tmp partition
9. An Overview of HPC: Using a System
Why would I use HPC resources?
• Large scale problems
• Parallelization and Efficiency
• Collaboration
How do I find an HPC resource?
• Check with your institution
• Check with national scientific groups (NSF in the US)
6/7/18 9
10. Overview: What Can I Find on a
System
Modules and Software
• Basic compilers and libraries
• Popular packages
• Licensed software
Build Your Own!
• github or other direct sources
• pip, wget, curl, etc
• You won’t have sudo access
6/7/18 10
11. What Do I Need to Get Started?
• User Account
• Allocation & Project
• Two Factor Authentication
6/7/18 11
12. Please See Your Handouts!
• Username
• Password
• Temporary TFA Key
6/7/18 12
13. SSH Protocols
Secure Shell
• Encrypted network protocol to access a secure system over an
unsecured network
• automatically generated public-private key pairs
• Your Wi-Fi Stampede2 or other secure machine
• File transfers (scp & rsync)
Options
• .ssh/config
• Host & Username
• Make connecting easier
• Passwordless Login
6/7/18 13
14. Logging In (Mac Terminal)
$ ssh <username>@stampede2.tacc.utexas.edu
To access the system:
1) If not using ssh-keys, please enter your TACC password at the password prompt
2) At the TACC Token prompt, enter your 6-digit code followed by <return>.
Password:
TACC Token Code:
6/7/18 14
17. Welcome to Stampede2, *please* read these important system notes:
--> Stampede2, Phase 2 Skylake nodes are now available for jobs
--> Stampede2 user documentation is available at:
https://portal.tacc.utexas.edu/user-guides/stampede2
----------------------- Project balances for user vtrue -----------------------
| Name Avail SUs Expires | |
| A-ccsc 189624 2018-12-31 | |
------------------------- Disk quotas for user vtrue --------------------------
| Disk Usage (GB) Limit %Used File Usage Limit %Used |
| /home1 1.9 10.0 19.43 39181 200000 19.59 |
| /work 311.8 1024.0 30.45 225008 3000000 7.50 |
| /scratch 0.0 0.0 0.00 4 0 0.00 |
-------------------------------------------------------------------------------
6/7/18 17
18. Where am I?
Login Nodes
• Manage files
• Build software
• Submit, monitor and manage jobs
Compute Nodes
• Running jobs
• Testing applications
6/7/18 18
19. Welcome to Stampede2, *please* read these important system notes:
--> Stampede2, Phase 2 Skylake nodes are now available for jobs
--> Stampede2 user documentation is available at:
https://portal.tacc.utexas.edu/user-guides/stampede2
----------------------- Project balances for user vtrue -----------------------
| Name Avail SUs Expires | |
| A-ccsc 189624 2018-12-31 | |
------------------------- Disk quotas for user vtrue --------------------------
| Disk Usage (GB) Limit %Used File Usage Limit %Used |
| /home1 1.9 10.0 19.43 39181 200000 19.59 |
| /work 311.8 1024.0 30.45 225008 3000000 7.50 |
| /scratch 0.0 0.0 0.00 4 0 0.00 |
-------------------------------------------------------------------------------
6/7/18 19
20. Allocations
Active Project with a Project Instructor attached
Service Units (SUs)
• SUs billed (node-hrs) = ( # nodes ) x (wall clock hours ) x ( charge
rate per node-hour )
Shared Systems
• Be a good citizen
6/7/18 20
21. Welcome to Stampede2, *please* read these important system notes:
--> Stampede2, Phase 2 Skylake nodes are now available for jobs
--> Stampede2 user documentation is available at:
https://portal.tacc.utexas.edu/user-guides/stampede2
----------------------- Project balances for user vtrue -----------------------
| Name Avail SUs Expires | |
| A-ccsc 189624 2018-12-31 | |
------------------------- Disk quotas for user vtrue --------------------------
| Disk Usage (GB) Limit %Used File Usage Limit %Used |
| /home1 1.9 10.0 19.43 39181 200000 19.59 |
| /work 311.8 1024.0 30.45 225008 3000000 7.50 |
| /scratch 0.0 0.0 0.00 4 0 0.00 |
-------------------------------------------------------------------------------
6/7/18 21
22. Filesystems
Division of Labor
• Linux Cluster (Lustre) system that look like a single hard disk space
• Small I/O is hard on the system
• Striping large data (OST, MDS)
Partitions
• $HOME: 10GB, $WORK: 1TB, $SCRATCH: Unlimited
• Shared system
6/7/18 22
24. Filesystems: Cont.
Where am I?
• pwd – print working directory
• cd – change directory
• cd .. – move up one directory
New Files
• mkdir – make directory
• Editors – vi(m), nano, emacs
• mv – move a file to another location
6/7/18 24
25. Create a File
login1.stampede2$ cd $WORK
login1.stampede2$ pwd
/work/03658/vtrue/stampede2
login1.stampede2$ nano helloWorld.py
6/7/18 25
26. 6/7/18 26
#!/usr/bin/env python
"""
Hello World
"""
import datetime as DT
today = DT.datetime.today()
print "Hello World! Today is:"
print today.strftime("%d %b %Y")
A Very Small File
27. Run an Interactive Job
idev
• Interactive development queue access command
• Watch your code run live
• Test things in real time
• idev –help for options
idev will drop you directly into the knl development queue so be
aware of your location on the system.
6/7/18 27
28. helloWorld.py
staff.stampede2(1005)$ idev
-> Checking on the status of development queue. OK
-> Defaults file : ~/.idevrc
-> System : stampede2
-> Queue : development (idev default )
[...]
c455-012[knl](1019)$
6/7/18 28
29. helloWorld.py
staff.stampede2(1005)$ idev
-> Checking on the status of development queue. OK
-> Defaults file : ~/.idevrc
-> System : stampede2
-> Queue : development (idev default )
[...]
c455-012[knl](1019)$ python helloWorld.py
Hello World! Today is:
17 Jun 2018
c455-012[knl](1020)$
6/7/18 29
30. Types of Code
Serial Code
• Albeit a very, very small one
• Single tasks, one after the other
• Single node/single core
Parallel Code
• Array or “embarrassingly parallel” jobs
• Many node/many core
• Uses MPI
• Hybrid codes
6/7/18 30
31. Message Passing Interface
ibrun isTACC specific
• “Wrapper” for mpirun
• Execute serial and parallel jobs across the entire node
MPI Functions
• Allows communication between all cores and all nodes
• Move data between parts of the job that need it
• Point-to-Point or Collective Communication
6/7/18 31
33. #!/usr/bin/env python
"""
Parallel Hello World
"""
from mpi4py import MPI
import sys
size = MPI.COMM_WORLD.Get_size()
rank = MPI.COMM_WORLD.Get_rank()
name = MPI.Get_processor_name()
sys.stdout.write(
"Hello, World! I am process %d of %d on %s.n"
% (rank, size, name))
6/7/18 33
34. Parallel helloWorld.py
c455-012[knl](1019)$ ibrun python helloParallel.py
TACC: Starting up job 1595632
TACC: Starting parallel tasks...
Hello, World! I am process 1 of 68 on c456-042.stampede2.tacc.utexas.edu.
Hello, World! I am process 49 of 68 on c456-042.stampede2.tacc.utexas.edu.
Hello, World! I am process 66 of 68 on c456-042.stampede2.tacc.utexas.edu.
Hello, World! I am process 67 of 68 on c456-042.stampede2.tacc.utexas.edu.
Hello, World! I am process 64 of 68 on c456-042.stampede2.tacc.utexas.edu.
...
TACC: Shutdown complete. Exiting.
6/7/18 34
35. Submitting a Job
Why submit?
• Larger jobs, more nodes
• You don’t have to watch it in real time
• Run multiple jobs simultaneously
Queues
• Pick the queues that suit your needs
• Don’t request more resources than you need
• Remember this is a shared resource
Never run on a login node!
6/7/18 35
36. 6/7/18 36
Queue Name Node Type
Max Nodes per
Job
Max Duration
Max Jobs in
Queue
Charge Rate
development KNL cache-quad 16 nodes 2hrs 1 1SU
normal KNL cache-quad 256 nodes 48hrs 50 1SU
large** KNL cache-quad 2048 nodes 48hrs 5 1SU
long KNL cache-quad 32 nodes 96hrs 2 1SU
flat-
quadrant
KNL flat-quad 24 nodes 48hrs 2 1SU
skx-dev SKX 4 nodes 2hrs 1 1SU
skx-normal SKX 128 nodes 48hrs 25 1SU
skx-large** SKX 868 nodes 48hrs 3 1SU
37. Submitting a Job cont.
sbatch
• Simple Linux Utility for Resource Management (SLURM)
• Linux/Unix workload manager
• Allocates resources
• Executes and monitors jobs
• Evaluates and manages pending jobs
Using a Scheduler
• Gets you off of the login nodes (shared resource)
• Means you can walk away and do other things
6/7/18 37
38. Submission Options
6/7/18 38
Option Argument Comments
-p queue_name Submits to queue (partition) designated by queue_name
-J job_name Job Name
-N total_nodes Required. Define the resources you need by specifying either:
(1) "-N" and "-n"; or (2) "-N" and "--ntasks-per-node".
-n total_tasks This is total MPI tasks in this job. When using this option in a non-MPI job, it is
usually best to set it to the same value as "-N".
-t hh:mm:ss Required. Wall clock time for job.
-o output_file Direct job standard output to output_file (without -e option error goes to this file)
-e error_file Direct job error output to error_file
-d= afterok:jobid Dependency: this run will start only after the specified job successfully finishes
-A projectnumber Charge job to the specified project/allocation number.
39. Parallel Job#!/bin/bash
#SBATCH -J myJob # Job name
#SBATCH -o myJob.o%j # Name of stdout output file
#SBATCH -e myJob.e%j # Name of stderr error file
#SBATCH -p development # Queue (partition) name
#SBATCH -N 1 # Total # of nodes
#SBATCH -n 68 # Total # of mpi tasks
#SBATCH -t 00:05:00 # Run time (hh:mm:ss)
#SBATCH -A myproject # Allocation name (req'd if you have more than 1)
#SBATCH --mail-user=hkang@austin.utexas.edu
#SBATCH --mail-type=all # Send email at begin and end of job
# Other commands must follow all #SBATCH directives...
module list
pwd
date
# Launch code...
ibrun python helloParallel.py
6/7/18 39
40. Managing Your Jobs
qlimits – all queues restrictions
sinfo – monitor queues in real time
squeue – monitor jobs in real time
showq – similar output to squeue
scancel – manually cancel a job
scontrol – detailed information about the configuration of a job
sacct – accounting data about your jobs
6/7/18 40
41. staff.stampede2(1009)$ squeue -u vtrue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
1604426 development idv20717 vtrue R 16:57 1 c455-001
staff.stampede2(1010)$ scontrol show job=1604426
JobId=1604426 JobName=idv20717
UserId=vtrue(829572) GroupId=G-815499(815499) MCS_label=N/A
Priority=400 Nice=0 Account=A-ccsc QOS=normal
JobState=RUNNING Reason=None Dependency=(null)
Requeue=0 Restarts=0 BatchFlag=1 Reboot=0 ExitCode=0:0
RunTime=00:18:08 TimeLimit=00:30:00 TimeMin=N/A
SubmitTime=2018-06-09T21:27:33 EligibleTime=2018-06-09T21:27:33
StartTime=2018-06-09T21:27:36 EndTime=2018-06-09T21:57:36 Deadline=N/A
PreemptTime=None SuspendTime=None SecsPreSuspend=0
LastSchedEval=2018-06-09T21:27:36
...
6/7/18 41
42. Accessing a Compute Node
No Job Running
staff(1003)$ ssh c455-001
Access denied: user vtrue
(uid=829572) has no active jobs
on this node.
Authentication failed.
Job Running
staff(1002)$ ssh c455-032
Last login: Fri Jun 15 15:46:04
2018 from
staff.stampede2.tacc.utexas.edu
TACC Stampede2 System
Provisioned on 24-May-2017 at
11:49
c455-032[knl](1001)$
6/7/18 42
43. On Node Monitoring
cat /proc/cpuinfo
• Follow a read out of the cpu info on the node
top
• See all of the processes running and which are consuming the most
resources
free –g
• Basic print out of memory consumption
Remora
• This is an open source tool developed by TACC that can help you
track memory, cpu usage, I/O activity, and other options
6/7/18 43
44. What else is on the Login Node?
Modules
• Find software, compilers, dependent packages
Environments
• Paths, personalizations, licenses
Building Software
• Install what you need, compile, update
6/7/18 44
45. Modules
Modules
• TACC uses a tool called Lmod
• Add, remove, and swap software packages
• Saves you from having to build your own
Commands
• module spider <package> - search for a package
• module list – see currently loaded modules
• module avail – list all available packages
• module load <package> - load a specific package or version
6/7/18 45
46. 6/7/18 46
staff.stampede2(1073)$ module list
Currently Loaded Modules:
1) intel/17.0.4 2) impi/17.0.3 3) git/2.9.0 4) autotools/1.1 5)
xalt/1.7.7 6) TACC 7) python2/2.7.14
staff.stampede2(1078)$ module spider python
----------------------------------------------------------------------------------------
python:
----------------------------------------------------------------------------------------
Versions:
python/2.7.13
Other possible modules matches:
python2 python3
----------------------------------------------------------------------------------------
To find other possible module matches execute:
$ module -r spider '.*python.*'
47. 6/7/18 47
staff.stampede2(1073)$ module spider python3/3.6.4
-------------------------------------------------------------------------------------
python3: python3/3.6.4
-------------------------------------------------------------------------------------
Description:
scientific scripting package
You will need to load all module(s) on any one of the lines below before the
"python3/3.6.4" module is available to load.
intel/17.0.4
Help:
This is the Python3 package built on March 01, 2018.
You can install your own modules (choose one method):
1. python3 setup.py install --user
2. python3 setup.py install --home=<dir>
3. pip3 install --user module-name
Version 3.6.4
48. Environment Management
env – Read out of all the environment variables set
Look for something specific:
staff.stampede2(1017)$ env | grep GIT
TACC_GIT_BIN=/opt/apps/git/2.9.0/bin
TACC_GIT_DIR=/opt/apps/git/2.9.0
TACC_GIT_LIB=/opt/apps/git/2.9.0/lib
GIT_TEMPLATE_DIR=/opt/apps/git/2.9.0/share/git-core/templates
GIT_EXEC_PATH=/opt/apps/git/2.9.0/libexec/git-core
6/7/18 48
55. What Else?
Any Software
• Build from source; get as complicated as you want
Customize login
• Modify .ssh/config on your local machine to meet your needs
Customize Editors
• Bring in outside configuration files (colors, layout, etc)
6/7/18 55
High Performance Computing most generally refers to the practice of aggregating computing power in a way that delivers much higher performance than one could get out of a typical desktop computer or workstation in order to solve large problems in science, engineering, or business.
Petaflop a unit of computing speed equal to one thousand million million (1015) floating-point operations per second.
Blue Waters is about 13.34 PF
What it does on the node will always be faster than on the filesystem bc of the interconnect of omnipath. High throughput low latency. Do things on the node then write out.
So what does a node look like on a super computer? My Mac here is 1 node with 4 cores and a similar clock rate. The full machine is 4,200 KNL compute nodes AND 1,736 SKX compute nodes.
Technically 72 but due to the way the KNL handles data only 68 are actually “functional” as far as the system is concerned
68 all together or 48 split between two. Different kinds of responses. Figure out what you’re doing and what your code can be made to accommodate
What does that look like when im directly on the node and not just theorizing about it? Knl node ex.
Non-uniform memory access (NUMA) is a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to the processor.
This is another way to visualize it. Each of these is a “logical cpu” rather than a physical cpu. Bc we have hyper threading turned on you can run 4 threads on every core resulting in a total possible 272 tasks if you are very very careful. Generally we see better results with 64> physical cores used. Hardware threads = physical cores, software threads = logical cores. Threads, tasks, cores, etc. we have 8 different names for the same things.
You’re working on climate data so your problem sets are huge. How many years? How granular? Do you want to develop visualizations? Predictive scaling? We could track Harvey in real time and predict where the deepest water was after the fact to help rescue crews manage their responses. We also kept legacy data for future study.
Application processes, depending on their model access may be free but access is in high demand so you have to prove that you’ll be doing valuable science on the machine
Now that you know a bit about what HPC systems involve, let’s try it out. What do I need to get started?
Ok, let’s get started!
We’ll come back to complex options later in the customizing your environment section. Programmers are lazy we don’t want to type more than we have to. On windows PuTTY is a ssh client
Inputs at password and token will likely appear blank so type carefully
If this doesn’t work in putty you may need to update settings on your machine:
In Settings app, go to Apps > Apps & features > Manage optional features.
Locate “OpenSSH server” feature, expand it, and select Install.
Object storage target and metadata server
Performance increases with filesystem size. But there are also caveats for long term storage associated with these resources
This is a rehash of Saturday but it will help you move around in what we’re going to do next
Pay attention to your command prompt. Ofc you can change this if you want but many systems have a default that is designed to be helpful .
Single processor
We’ll get to multithreading in a minute and how that actually works vs hyperthreading
A lot of people will use the fact that there are more cores on a node some people will run across it repeatedly for more through put
Point to point is communication between to processes so task 1 on core 1 talks to core 2 etc. Collective communication implies a synchronization point. All of your tasks much get to a certain point before moving to the next step (barrier) or broadcast, from single point send out the same data to other processors. You can get super fancy with this and build tree structures to help your code. Paired things like vectorization this becomes very important for increasing the performance of your code at a larger scale.
You can do this for as many logical cores are on the node or you can do it between nodes. But specify which you’re doing in your code or your just going to trip it up.
Point to point can be send/receive or a send or a receive separately and can go between any single core. This can be in order or not but its not the same thing being pushed out across multiple cores that is a “broadcast” the reverse can be “gathering” as in scatter and gather
Single node/task = one output
Shift + ZZ to save and exit
ls to see if file was saved
We’ll come back for this later when we start running some examples but for now make sure it’s saved and try to remember where you put it
Single processor per task (multithreaded) but not yet hyperthreaded
Great! Now you know how to run jobs interactively
So many more options available. What’s available? See the queues!
Varies based on the number of nodes the system has and the frequency of use. Large queues are special as they take up so much of the system and a poorly run job could a) cause system problems b) cost you a lot of SUs that you wont get refunded.
Cache-quad and flat-quad has to do with the way memory is distributed. We keep most of the knl’s in cache bc the response time is faster but sometimes that means there is less room for certain operations. If your code is heavier on the memory switch to flat quad so you can get the full memory available. Instead of 16+96 you get 112GB flat.
Cache Mode. In this mode, the fast MCDRAM is configured as an L3 cache. The operating system transparently uses the MCDRAM to move data from main memory. In this mode, the user has access to 96GB of RAM, all of it traditional DDR4. Most Stampede2 KNL nodes are configured in cache mode.
Flat Mode. In this mode, DDR4 and MCDRAM act as two distinct Non-Uniform Memory Access (NUMA) nodes. It is therefore possible to specify the type of memory (DDR4 or MCDRAM) when allocating memory. In this mode, the user has access to 112GB of RAM: 96GB of traditional DDR and 16GB of fast MCDRAM. By default, memory allocations occur only in DDR4. To use MCDRAM in flat mode, use the numactl utility or the memkind library; see Managing Memory for more information. If you do not modify the default behavior you will have access only to the slower DDR4.
This is how the system knows what’s trying to run. Helps manager resources and tries to keep things “fair” is generally automated though can be manipulated by admins.
This isn’t all options but it covers the most commonly used ones and the ones that are required. You have to tell the system what you are trying to do and this is how you communicate with it via the work load manager.
“slurm batch”
Lua based module system. A modulefile contains the necessary information to allow a user to run a particular application or provide access to a particular library. All of this can be done dynamically without logging out and back in. Modulefiles for applications modify the user's path to make access easy. Modulefiles for Library packages provide environment variables that specify where the library and header files can be found. It is also very easy to switch between different versions of a package or remove the package.
Module -help
Lua based module system. A modulefile contains the necessary information to allow a user to run a particular application or provide access to a particular library. All of this can be done dynamically without logging out and back in. Modulefiles for applications modify the user's path to make access easy. Modulefiles for Library packages provide environment variables that specify where the library and header files can be found. It is also very easy to switch between different versions of a package or remove the package.
Module -help
Suggestions. READ!! It will often tell you what you need to know about the package
Suggestions. READ!! It will often tell you what you need to know about the package
We’ll address some more commands later …like squeue etc
These are the two most important things to keep track of where the system looks for executables and libraries. The order of these _matters_ it will pick what it finds first and stick with it and ignore subsequent matching pieces. You can change these to accommodate installing new software but be careful.
If anything is no correct it will say “FAILED” and then provide you with instructions
Show live demo for this
Aliases are short cuts and are your best friend
Downloading from git or direct requires you then update paths to make it universally usable
This is a terrible example but it’s straightforward. You have to put the path update in your .bashrc if you want it to stick once you logout