Two-level CheCL is proposed to improve the scalability of transparent checkpointing for GPU computing systems. It utilizes both local node storage and global storage to balance checkpoint speed and reliability. Local CheCL checkpoints to local storage are fast but less reliable, while global storage checkpoints are slower but more reliable. Experimental results show Two-level CheCL can accelerate checkpoint time by up to 4x compared to using just global storage, and improve application efficiency especially with higher failure rates. The ratio of local to global checkpointing affects the overhead.
Reshaping Core Genomics Software Tools for the Manycore EraIntel® Software
This session provides an overview of the results from a multiyear collaboration with engineers at Intel to revamp Bowtie and Bowtie 2 (and another related tool called HISAT) to make effective use of all the processor cores on modern Intel® CPUs.
Exploiting the Linux Kernel via Intel's SYSRET Implementationnkslides
Intel handles SYSRET instructions weirdly and might throw around exceptions while still being in ring0. When the kernel is not being extra careful when returning to userland after being signaled with a syscall bad things can happen. Like root shells.
Performance Analysis Tools for Linux Kernellcplcp1
Perf is a collection of Linux kernel tools for performance monitoring and profiling. It provides sampling and profiling of the system to analyze performance bottlenecks. Perf supports hardware events from the CPU performance counters, software events from the kernel, and tracepoint events from the kernel and loaded modules. It offers tools like perf record to sample events and store them, perf report to analyze stored samples, and perf trace to trace system events in real-time.
Speculative Execution of Parallel Programs with Precise Exception Semantics ...Akihiro Hayashi
Akihiro Hayashi, Max Grossman, Jisheng Zhao, Jun Shirako, Vivek Sarkar. The 26th International Workshop on Languages and Compilers for Parallel Computing (LCPC2013), September 25-27, 2013 Qualcomm Research Silicon Valley, Santa Clara, CA (co-located with CnC-2013).
The document provides an overview of eBPF maps and how they can be used to share data between eBPF programs running in the kernel and userspace applications. It describes how maps are created via the BPF syscall using the BPF_MAP_CREATE command. It also explains how keys and values can be looked up, updated, and deleted from maps using commands like BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, and BPF_MAP_DELETE_ELEM. Finally, it lists the different types of eBPF maps available.
In this talk, Gil Yankovitch discusses the PaX patch for the Linux kernel, focusing on memory manager changes and security mechanisms for memory allocations, reads, writes from user/kernel space and ASLR.
UM2019 Extended BPF: A New Type of SoftwareBrendan Gregg
BPF (Berkeley Packet Filter) has evolved from a limited virtual machine for efficient packet filtering to a new type of software called extended BPF. Extended BPF allows for custom, efficient, and production-safe performance analysis tools and observability programs to be run in the Linux kernel through BPF. It enables new event-based applications running as BPF programs attached to various kernel events like kprobes, uprobes, tracepoints, sockets, and more. Major companies like Facebook, Google, and Netflix are using BPF programs for tasks like intrusion detection, container security, firewalling, and observability with over 150,000 AWS instances running BPF programs. BPF provides a new program model and security features compared
Mechanisms and tools of development and monitoring in Linux Kernel
A brief presentation about the tools and mechanisms about development for the Linux Kernel to help understanding of what is required.
Tools that create an execution profile or provide instrumentation through static or dynamic methods, the Linux Kernel code, will be presented.
Also discussed will be the GDB debugger and how through a remote virtual serial connection to a virtual machine it can be used to debug a live Kernel and Linux Kernel modules. Also demonstrated will be how a deeper understanding of the code can be attained by attaching the memory locations used by the Kernel module to the GDB session.
Lastly, some of the Kernel execution contexts, such as, interrupts, deferrable work, context, etc. are presented.
Reshaping Core Genomics Software Tools for the Manycore EraIntel® Software
This session provides an overview of the results from a multiyear collaboration with engineers at Intel to revamp Bowtie and Bowtie 2 (and another related tool called HISAT) to make effective use of all the processor cores on modern Intel® CPUs.
Exploiting the Linux Kernel via Intel's SYSRET Implementationnkslides
Intel handles SYSRET instructions weirdly and might throw around exceptions while still being in ring0. When the kernel is not being extra careful when returning to userland after being signaled with a syscall bad things can happen. Like root shells.
Performance Analysis Tools for Linux Kernellcplcp1
Perf is a collection of Linux kernel tools for performance monitoring and profiling. It provides sampling and profiling of the system to analyze performance bottlenecks. Perf supports hardware events from the CPU performance counters, software events from the kernel, and tracepoint events from the kernel and loaded modules. It offers tools like perf record to sample events and store them, perf report to analyze stored samples, and perf trace to trace system events in real-time.
Speculative Execution of Parallel Programs with Precise Exception Semantics ...Akihiro Hayashi
Akihiro Hayashi, Max Grossman, Jisheng Zhao, Jun Shirako, Vivek Sarkar. The 26th International Workshop on Languages and Compilers for Parallel Computing (LCPC2013), September 25-27, 2013 Qualcomm Research Silicon Valley, Santa Clara, CA (co-located with CnC-2013).
The document provides an overview of eBPF maps and how they can be used to share data between eBPF programs running in the kernel and userspace applications. It describes how maps are created via the BPF syscall using the BPF_MAP_CREATE command. It also explains how keys and values can be looked up, updated, and deleted from maps using commands like BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, and BPF_MAP_DELETE_ELEM. Finally, it lists the different types of eBPF maps available.
In this talk, Gil Yankovitch discusses the PaX patch for the Linux kernel, focusing on memory manager changes and security mechanisms for memory allocations, reads, writes from user/kernel space and ASLR.
UM2019 Extended BPF: A New Type of SoftwareBrendan Gregg
BPF (Berkeley Packet Filter) has evolved from a limited virtual machine for efficient packet filtering to a new type of software called extended BPF. Extended BPF allows for custom, efficient, and production-safe performance analysis tools and observability programs to be run in the Linux kernel through BPF. It enables new event-based applications running as BPF programs attached to various kernel events like kprobes, uprobes, tracepoints, sockets, and more. Major companies like Facebook, Google, and Netflix are using BPF programs for tasks like intrusion detection, container security, firewalling, and observability with over 150,000 AWS instances running BPF programs. BPF provides a new program model and security features compared
Mechanisms and tools of development and monitoring in Linux Kernel
A brief presentation about the tools and mechanisms about development for the Linux Kernel to help understanding of what is required.
Tools that create an execution profile or provide instrumentation through static or dynamic methods, the Linux Kernel code, will be presented.
Also discussed will be the GDB debugger and how through a remote virtual serial connection to a virtual machine it can be used to debug a live Kernel and Linux Kernel modules. Also demonstrated will be how a deeper understanding of the code can be attained by attaching the memory locations used by the Kernel module to the GDB session.
Lastly, some of the Kernel execution contexts, such as, interrupts, deferrable work, context, etc. are presented.
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.
This document provides an overview of cBPF and eBPF. It discusses the history and implementation of cBPF, including how it was originally used for packet filtering. It then covers eBPF in more depth, explaining what it is, its history, implementation including different program types and maps. It also discusses several uses of eBPF including networking, firewalls, DDoS mitigation, profiling, security, and chaos engineering. Finally, it introduces XDP and DPDK, comparing XDP's benefits over DPDK.
The document describes a biolatency tool that traces block device I/O latency using eBPF. It discusses how the tool was originally written in the bcc framework using C/BPF, but has since been rewritten in the bpftrace framework using a simpler one-liner script. It provides examples of the bcc and bpftrace implementations of biolatency.
Nadav Markus goes over the path from a simple crash POC provided by Google Project Zero (for CVE-2015-7547), to a fully weaponized exploit.
He explores how an attacker can utilize the behavior of the Linux kernel in order to bypass ASLR, allowing an attacker to remotely execute code on vulnerable targets.
Agenda:
In this session, Shmulik Ladkani discusses the kernel's net_device abstraction, its interfaces, and how net-devices interact with the network stack. The talk covers many of the software network devices that exist in the Linux kernel, the functionalities they provide and some interesting use cases.
Speaker:
Shmulik Ladkani is a Tech Lead at Ravello Systems.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
51966 coffees and billions of forwarded packets later, with millions of homes running his software, Shmulik left his position as Jungo’s lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud service. He's now focused around virtualization systems, network virtualization and SDN.
This document discusses device drivers for timers, real-time clocks (RTCs), and watchdog timers in Linux. It provides code examples for initializing system timers, implementing RTC driver IOCTL commands, and registering new RTC drivers that use the RTC class structure. It also describes what a watchdog timer is and things to note when using one, such as potential file system crashes from direct CPU resets.
Linux kernel tracing superpowers in the cloudAndrea Righi
The Linux 4.x series introduced a new powerful engine of programmable tracing (BPF) that allows to actually look inside the kernel at runtime. This talk will show you how to exploit this engine in order to debug problems or identify performance bottlenecks in a complex environment like a cloud. This talk will cover the latest Linux superpowers that allow to see what is happening “under the hood” of the Linux kernel at runtime. I will explain how to exploit these “superpowers” to measure and trace complex events at runtime in a cloud environment. For example, we will see how we can measure latency distribution of filesystem I/O, details of storage device operations, like individual block I/O request timeouts, or TCP buffer allocations, investigating stack traces of certain events, identify memory leaks, performance bottlenecks and a whole lot more.
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."
This document contains the slides from a presentation given by WonoKaerun at the Indonesian Security Conference 2011 in Palembang. The presentation introduces rootkits and techniques for hiding malware at the kernel level on Linux systems. It covers topics like loadable kernel modules, interrupt descriptor table hooking, virtual file system hacking, page fault handler hijacking, debugging register abuse, and kernel instrumentation patching. The goal is to evade detection by security solutions by gaining control of the kernel before anti-rootkit defenses can activate. Throughout, the document emphasizes the cat-and-mouse nature of offensive and defensive security research.
This document summarizes a presentation about tuning parallel code on Solaris. It discusses:
1) Using tools like DTrace, prstat, and vmstat to analyze performance issues like thread scheduling and I/O problems in parallel applications on Solaris.
2) Two examples of using DTrace to analyze thread scheduling and troubleshoot I/O performance problems in a virtualized Windows server.
3) How the examples demonstrated using DTrace to identify unbalanced thread scheduling and discover that a domain controller was disabling disk write caching, slowing performance.
eBPF is an exciting new technology that is poised to transform Linux performance engineering. eBPF enables users to dynamically and programatically trace any kernel or user space code path, safely and efficiently. However, understanding eBPF is not so simple. The goal of this talk is to give audiences a fundamental understanding of eBPF, how it interconnects existing Linux tracing technologies, and provides a powerful aplatform to solve any Linux performance problem.
Here is a bpftrace program to measure scheduler latency for ICMP echo requests:
#!/usr/local/bin/bpftrace
kprobe:icmp_send {
@start[tid] = nsecs;
}
kprobe:__netif_receive_skb_core {
@diff[tid] = hist(nsecs - @start[tid]);
delete(@start[tid]);
}
END {
print(@diff);
clear(@diff);
}
This traces the time between the icmp_send kernel function (when the packet is queued for transmit) and the __netif_receive_skb_core function (when the response packet is received). The
Kernel Recipes 2015: Introduction to Kernel Power ManagementAnne Nicolas
The document introduces kernel power management concepts in Linux, including static and dynamic power management, idle power management for CPUs and devices, and the evolving driver model. It covers key frameworks like CPU frequency scaling, regulators, runtime power management, and power domains. Documentation files are referenced throughout for further reading.
Tracing MariaDB server with bpftrace - MariaDB Server Fest 2021Valeriy Kravchuk
Bpftrace is a relatively new eBPF-based open source tracer for modern Linux versions (kernels 5.x.y) that is useful for analyzing production performance problems and troubleshooting software. Basic usage of the tool, as well as bpftrace one liners and advanced scripts useful for MariaDB DBAs are presented. Problems of MariaDB Server dynamic tracing with bpftrace and some possible solutions and alternative tracing tools are discussed.
This document discusses concurrency and concurrent programming in Java. It introduces the built-in concurrency primitives like wait(), notify(), synchronized, and volatile. It then discusses higher-level concurrency utilities and data structures introduced in JDK 5.0 like Executors, ExecutorService, ThreadPools, Future, Callable, ConcurrentHashMap, CopyOnWriteArrayList that provide safer and more usable concurrency constructs. It also briefly covers topics like Java Memory Model, memory barriers, and happens-before ordering.
The document discusses merging the KGDB, KDB, and KMS components to provide a simple, reliable, multi-architecture kernel debugger that can work with graphics or serial interfaces. It describes the goals of merging the components, provides examples of their individual designs, and outlines challenges and future work in fully integrating them and upstreaming the work.
The document discusses several techniques for handling priority inversion in real-time operating systems:
1) The Priority Inheritance Protocol dynamically changes the priority of any task in a critical section to the priority of the highest task pending on the same critical resource.
2) The Priority Ceiling Protocol assigns each resource a priority ceiling equal to the priority of the highest priority task that can use it.
3) The Original Ceiling Priority Protocol assigns static default priorities and ceiling values to processes and resources, with processes able to lock resources only if their dynamic priority is higher than the ceiling.
Since the emerging of the OpenStack cloud computing platform in the Ubuntu community, increasing number of public/private cloud service providers choose to deploy it all over the world. Recently, Spectre and Meltdown have caused a panic in the world and the Spectre V2 is the only one which can attack the host system from the guest VM. It's vital to know the detailed process of the attack. Gavin Guo will give a detail explanation and an example of how to attack the host system. Besides, v1/v3/v4 are also introduced in the slide.
This talk is all about the Berkeley Packet Filters (BPF) and their uses in Linux.
Agenda:
* What is a BPF and why do we need it?
* Writing custom BPFs
* Notes on BPF implementation in the kernel
* Usage examples: SOCKET_FILTER & seccomp
Speaker:
Kfir Gollan, senior embedded software developer, Linux kernel hacker and software team leader.
Building Network Functions with eBPF & BCCKernel TLV
eBPF (Extended Berkeley Packet Filter) is an in-kernel virtual machine that allows running user-supplied sandboxed programs inside of the kernel. It is especially well-suited to network programs and it's possible to write programs that filter traffic, classify traffic and perform high-performance custom packet processing.
BCC (BPF Compiler Collection) is a toolkit for creating efficient kernel tracing and manipulation programs. It makes use of eBPF.
BCC provides an end-to-end workflow for developing eBPF programs and supplies Python bindings, making eBPF programs much easier to write.
Together, eBPF and BCC allow you to develop and deploy network functions safely and easily, focusing on your application logic (instead of kernel datapath integration).
In this session, we will introduce eBPF and BCC, explain how to implement a network function using BCC, discuss some real-life use-cases and show a live demonstration of the technology.
About the speaker
Shmulik Ladkani, Chief Technology Officer at Meta Networks,
Long time network veteran and kernel geek.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
Some billions of forwarded packets later, Shmulik left his position as Jungo's lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud-based service, focusing around virtualization systems, network virtualization and SDN.
Recently he co-founded Meta Networks where he's been busy architecting secure, multi-tenant, large-scale network infrastructure as a cloud-based service.
The document discusses Nalco's ethanol corrosion inhibitor product EC5624A PLUS. It provides reasons to choose the product, including Nalco's experience in formulating fuel additives, membership in industry organizations, and large customer base. It describes benefits of EC5624A PLUS such as improved consistency, effective corrosion protection, and easy measurement using a handheld instrument. The document also covers operator training, monthly on-site service, and tracer technology used to accurately measure treat rates.
Why alcohols will replace gasoline and diesel fuel to be the fuels of the fut...SolarClean Fuels, LLC
The document discusses why alcohols like ethanol and methanol will replace gasoline and diesel as future fuels. It outlines some of the key issues with gasoline such as supply constraints and health and environmental impacts. It then summarizes some alternative fuel options like electric cars, natural gas, and biofuels. Ethanol from corn is discussed but has limitations due to feedstock constraints. Cellulosic ethanol and methanol produced from various waste sources are presented as promising alternatives. The document argues that alcohols can provide engine efficiencies similar to diesel engines without the same emissions issues. It proposes a "GEM" concept of blending gasoline, ethanol and methanol to allow existing vehicles to use higher methanol blends right away while cellulos
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.
This document provides an overview of cBPF and eBPF. It discusses the history and implementation of cBPF, including how it was originally used for packet filtering. It then covers eBPF in more depth, explaining what it is, its history, implementation including different program types and maps. It also discusses several uses of eBPF including networking, firewalls, DDoS mitigation, profiling, security, and chaos engineering. Finally, it introduces XDP and DPDK, comparing XDP's benefits over DPDK.
The document describes a biolatency tool that traces block device I/O latency using eBPF. It discusses how the tool was originally written in the bcc framework using C/BPF, but has since been rewritten in the bpftrace framework using a simpler one-liner script. It provides examples of the bcc and bpftrace implementations of biolatency.
Nadav Markus goes over the path from a simple crash POC provided by Google Project Zero (for CVE-2015-7547), to a fully weaponized exploit.
He explores how an attacker can utilize the behavior of the Linux kernel in order to bypass ASLR, allowing an attacker to remotely execute code on vulnerable targets.
Agenda:
In this session, Shmulik Ladkani discusses the kernel's net_device abstraction, its interfaces, and how net-devices interact with the network stack. The talk covers many of the software network devices that exist in the Linux kernel, the functionalities they provide and some interesting use cases.
Speaker:
Shmulik Ladkani is a Tech Lead at Ravello Systems.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
51966 coffees and billions of forwarded packets later, with millions of homes running his software, Shmulik left his position as Jungo’s lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud service. He's now focused around virtualization systems, network virtualization and SDN.
This document discusses device drivers for timers, real-time clocks (RTCs), and watchdog timers in Linux. It provides code examples for initializing system timers, implementing RTC driver IOCTL commands, and registering new RTC drivers that use the RTC class structure. It also describes what a watchdog timer is and things to note when using one, such as potential file system crashes from direct CPU resets.
Linux kernel tracing superpowers in the cloudAndrea Righi
The Linux 4.x series introduced a new powerful engine of programmable tracing (BPF) that allows to actually look inside the kernel at runtime. This talk will show you how to exploit this engine in order to debug problems or identify performance bottlenecks in a complex environment like a cloud. This talk will cover the latest Linux superpowers that allow to see what is happening “under the hood” of the Linux kernel at runtime. I will explain how to exploit these “superpowers” to measure and trace complex events at runtime in a cloud environment. For example, we will see how we can measure latency distribution of filesystem I/O, details of storage device operations, like individual block I/O request timeouts, or TCP buffer allocations, investigating stack traces of certain events, identify memory leaks, performance bottlenecks and a whole lot more.
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."
This document contains the slides from a presentation given by WonoKaerun at the Indonesian Security Conference 2011 in Palembang. The presentation introduces rootkits and techniques for hiding malware at the kernel level on Linux systems. It covers topics like loadable kernel modules, interrupt descriptor table hooking, virtual file system hacking, page fault handler hijacking, debugging register abuse, and kernel instrumentation patching. The goal is to evade detection by security solutions by gaining control of the kernel before anti-rootkit defenses can activate. Throughout, the document emphasizes the cat-and-mouse nature of offensive and defensive security research.
This document summarizes a presentation about tuning parallel code on Solaris. It discusses:
1) Using tools like DTrace, prstat, and vmstat to analyze performance issues like thread scheduling and I/O problems in parallel applications on Solaris.
2) Two examples of using DTrace to analyze thread scheduling and troubleshoot I/O performance problems in a virtualized Windows server.
3) How the examples demonstrated using DTrace to identify unbalanced thread scheduling and discover that a domain controller was disabling disk write caching, slowing performance.
eBPF is an exciting new technology that is poised to transform Linux performance engineering. eBPF enables users to dynamically and programatically trace any kernel or user space code path, safely and efficiently. However, understanding eBPF is not so simple. The goal of this talk is to give audiences a fundamental understanding of eBPF, how it interconnects existing Linux tracing technologies, and provides a powerful aplatform to solve any Linux performance problem.
Here is a bpftrace program to measure scheduler latency for ICMP echo requests:
#!/usr/local/bin/bpftrace
kprobe:icmp_send {
@start[tid] = nsecs;
}
kprobe:__netif_receive_skb_core {
@diff[tid] = hist(nsecs - @start[tid]);
delete(@start[tid]);
}
END {
print(@diff);
clear(@diff);
}
This traces the time between the icmp_send kernel function (when the packet is queued for transmit) and the __netif_receive_skb_core function (when the response packet is received). The
Kernel Recipes 2015: Introduction to Kernel Power ManagementAnne Nicolas
The document introduces kernel power management concepts in Linux, including static and dynamic power management, idle power management for CPUs and devices, and the evolving driver model. It covers key frameworks like CPU frequency scaling, regulators, runtime power management, and power domains. Documentation files are referenced throughout for further reading.
Tracing MariaDB server with bpftrace - MariaDB Server Fest 2021Valeriy Kravchuk
Bpftrace is a relatively new eBPF-based open source tracer for modern Linux versions (kernels 5.x.y) that is useful for analyzing production performance problems and troubleshooting software. Basic usage of the tool, as well as bpftrace one liners and advanced scripts useful for MariaDB DBAs are presented. Problems of MariaDB Server dynamic tracing with bpftrace and some possible solutions and alternative tracing tools are discussed.
This document discusses concurrency and concurrent programming in Java. It introduces the built-in concurrency primitives like wait(), notify(), synchronized, and volatile. It then discusses higher-level concurrency utilities and data structures introduced in JDK 5.0 like Executors, ExecutorService, ThreadPools, Future, Callable, ConcurrentHashMap, CopyOnWriteArrayList that provide safer and more usable concurrency constructs. It also briefly covers topics like Java Memory Model, memory barriers, and happens-before ordering.
The document discusses merging the KGDB, KDB, and KMS components to provide a simple, reliable, multi-architecture kernel debugger that can work with graphics or serial interfaces. It describes the goals of merging the components, provides examples of their individual designs, and outlines challenges and future work in fully integrating them and upstreaming the work.
The document discusses several techniques for handling priority inversion in real-time operating systems:
1) The Priority Inheritance Protocol dynamically changes the priority of any task in a critical section to the priority of the highest task pending on the same critical resource.
2) The Priority Ceiling Protocol assigns each resource a priority ceiling equal to the priority of the highest priority task that can use it.
3) The Original Ceiling Priority Protocol assigns static default priorities and ceiling values to processes and resources, with processes able to lock resources only if their dynamic priority is higher than the ceiling.
Since the emerging of the OpenStack cloud computing platform in the Ubuntu community, increasing number of public/private cloud service providers choose to deploy it all over the world. Recently, Spectre and Meltdown have caused a panic in the world and the Spectre V2 is the only one which can attack the host system from the guest VM. It's vital to know the detailed process of the attack. Gavin Guo will give a detail explanation and an example of how to attack the host system. Besides, v1/v3/v4 are also introduced in the slide.
This talk is all about the Berkeley Packet Filters (BPF) and their uses in Linux.
Agenda:
* What is a BPF and why do we need it?
* Writing custom BPFs
* Notes on BPF implementation in the kernel
* Usage examples: SOCKET_FILTER & seccomp
Speaker:
Kfir Gollan, senior embedded software developer, Linux kernel hacker and software team leader.
Building Network Functions with eBPF & BCCKernel TLV
eBPF (Extended Berkeley Packet Filter) is an in-kernel virtual machine that allows running user-supplied sandboxed programs inside of the kernel. It is especially well-suited to network programs and it's possible to write programs that filter traffic, classify traffic and perform high-performance custom packet processing.
BCC (BPF Compiler Collection) is a toolkit for creating efficient kernel tracing and manipulation programs. It makes use of eBPF.
BCC provides an end-to-end workflow for developing eBPF programs and supplies Python bindings, making eBPF programs much easier to write.
Together, eBPF and BCC allow you to develop and deploy network functions safely and easily, focusing on your application logic (instead of kernel datapath integration).
In this session, we will introduce eBPF and BCC, explain how to implement a network function using BCC, discuss some real-life use-cases and show a live demonstration of the technology.
About the speaker
Shmulik Ladkani, Chief Technology Officer at Meta Networks,
Long time network veteran and kernel geek.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
Some billions of forwarded packets later, Shmulik left his position as Jungo's lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud-based service, focusing around virtualization systems, network virtualization and SDN.
Recently he co-founded Meta Networks where he's been busy architecting secure, multi-tenant, large-scale network infrastructure as a cloud-based service.
The document discusses Nalco's ethanol corrosion inhibitor product EC5624A PLUS. It provides reasons to choose the product, including Nalco's experience in formulating fuel additives, membership in industry organizations, and large customer base. It describes benefits of EC5624A PLUS such as improved consistency, effective corrosion protection, and easy measurement using a handheld instrument. The document also covers operator training, monthly on-site service, and tracer technology used to accurately measure treat rates.
Why alcohols will replace gasoline and diesel fuel to be the fuels of the fut...SolarClean Fuels, LLC
The document discusses why alcohols like ethanol and methanol will replace gasoline and diesel as future fuels. It outlines some of the key issues with gasoline such as supply constraints and health and environmental impacts. It then summarizes some alternative fuel options like electric cars, natural gas, and biofuels. Ethanol from corn is discussed but has limitations due to feedstock constraints. Cellulosic ethanol and methanol produced from various waste sources are presented as promising alternatives. The document argues that alcohols can provide engine efficiencies similar to diesel engines without the same emissions issues. It proposes a "GEM" concept of blending gasoline, ethanol and methanol to allow existing vehicles to use higher methanol blends right away while cellulos
This presentation introduces the integration of models for inquiry-based learning and feedback with crowd sensing approaches in order to create solutions that are applicable in the real world.
Oil 101 - Introduction to Petroleum Product MarketingEKT Interactive
Oil 101 - A Free Introduction to Oil and Gas
Introduction to Marketing - Retail and Wholesale
This petroleum product marketing overview includes discussions on What is Marketing, the structure and key functions of oil company marketing departments, and some historical perspective on how demand for transportation fuels, including service stations came, to dominate US landscape.
The complete Petroleum Product Marketing Module includes lessons on marketing fundamentals, retail vs wholesale marketing, and key business drivers and processes in petroleum product marketing.
What is Petroleum Product Marketing?
As we stated earlier, Marketing is the final step in the ‘Microbes to Markets’ chain that delivers useful petroleum products to end-user customers. The main business drivers of this segment are volume, market share and margin.
Worldwide, transportation fuels including gasoline, diesel, jet fuel and marine fuel oil account the largest percentage of global demand, and it is the fastest growing portion of refinery products.
In the United States, passenger cars still consume more petroleum products than any other sector. Today, the US accounts for about 44% of the world’s gasoline consumption, and transportation fuels are 65% of the US demand.
Since the US has one of the most competitive retail markets in the world, it has been a leading indicator in development of new service station formats. Many of these retail formats are adopted around the world – with some customization to accommodate local legislation and consumer preferences.
Modifications are needed in gasoline engines to use ethanol fuel blends. For blends up to E10, no changes are typically needed. For higher blends, modifications like increasing the diameter of inlet orifices and the accelerator pump are required to properly adjust the air-fuel ratio. Additional changes like increasing the compression ratio or installing pre-heating systems may be needed for cold starting when using high-ethanol blends. Proper adjustments can help utilize the higher octane and cleaner burning properties of ethanol fuel in engines.
Research report on phil. housing finance sector of PhilippinesNelsie Grace Pineda
This is a research report I made last year for school requirements.The housing finance sector of Philippines is emphasized here with comprehensive details of housing situation in the country.
I hope this can be of help!
The document provides an overview of a marketing class for small business owners. It discusses the importance of having a business plan and marketing strategy. The class will help attendees write the business and marketing sections of their plans by identifying their target market and competitors, developing a positioning statement, and choosing appropriate marketing tactics. Attendees will learn how to clearly describe their business and communicate its value to potential customers.
The document discusses the political and legal environments that multinational enterprises must consider when operating in different countries. It covers various political systems like democracy and totalitarianism. It also discusses political risks companies may face like government actions that could negatively impact operations. The legal environment section focuses on different types of legal systems like common law and civil law. The document provides an overview of key factors in the political and legal environments that international businesses must analyze.
This document discusses the political and legal environments that multinational enterprises must consider when operating in different countries. It covers various political systems and ideologies around the world, such as democracy, totalitarianism, and different forms of government intervention in the economy. The document also discusses political risks, establishing political strategies, different legal systems, and the role of lobbying in influencing government decisions.
The document discusses the marketing environment, which includes forces outside of a company's direct control that influence its business capabilities. It describes the internal environment within a company and the external macro and micro environments. The macro environment encompasses broad societal forces, while the micro environment consists of suppliers, customers, competitors, and public groups in the immediate industry. Understanding how these environments shape opportunities and threats is essential for effective marketing planning and competition.
Macro factors affecting business environmentaayush30
This document discusses macro factors that affect a business's external environment. It defines business and explains that businesses operate within multiple levels of environmental forces, both internal and external. The external forces can provide opportunities or threats and come from the national, regional, or international level. The document then discusses the systems approach to understanding a business's environment, noting that while managers can control internal aspects, broader external systems like the industry, country, region, and global levels are less controllable. It identifies the key components of a business environment as the internal environment and external environment, which includes economic, socio-cultural, political-legal, technological, and international factors.
Exploitation of counter overflows in the Linux kernelVitaly Nikolenko
This document summarizes an exploit talk on counter overflows in the Linux kernel. It discusses how counter overflows can be used to exploit vulnerabilities by overflowing reference counters and triggering object deallocation. It provides examples of real counter overflow vulnerabilities in Linux, such as CVE-2014-2851 and CVE-2016-0728, and outlines the general exploitation procedure, including overflowing the counter, triggering object freeing, overwriting data, and executing code. It also discusses challenges like integer overflow times and techniques like using RCU calls to bypass checks.
This document summarizes a three-part challenge involving cracking a MIPS binary, exploiting a Python/XXE vulnerability in a web application, and decrypting messages from a SecureDrop-like system. The MIPS binary is cracked by inverting its password checking algorithm. The web app is exploited via XXE to retrieve files containing an admin URL and view state details. Python code is modified at runtime to decrypt an AES key and access a "secret.key" file. This key reveals a tarball containing a SecureDrop implementation. A buffer overflow in SecDrop's service is used to run shellcode. Timing attacks via the CPU cache are then used to retrieve the private RSA key and decrypt messages stored by the SecureDrop-
Linux High Availability provides information on configuring high availability clusters in Linux. It discusses:
- Key components of HA clustering including one service taking over work of another if it fails, IP and service takeover.
- The importance of high availability and costs of downtime for businesses. Statistics show significant downtime even at 99.9% availability levels.
- Best practices for HA including keeping configurations simple, preparing for failures, and testing HA setups. Complexity increases reliability risks.
The document discusses dynamically hacking the Linux kernel with containers. It begins by introducing the speaker and their research interests. It then discusses three ways to modify the kernel space: kernel modules, live patching, and kernel detouring. Kernel detouring allows hijacking system calls within containers for cross-OS compatibility. Challenges include insufficient isolation and limited development. The talk demonstrates a proof-of-concept of running FreeBSD binaries on Linux using kernel detouring and containers. It remapped Linux system calls to FreeBSD equivalents and provided a FreeBSD environment within a Linux container.
RTOS Material hfffffffffffffffffffffffffffffffffffffadugnanegero
This document provides an overview of real-time operating systems and kernel concepts across 34 slides. The key topics covered include real-time kernels, tasks and processes, scheduling algorithms like priority-based and cyclic executives, intertask communication methods like mailboxes and semaphores, and synchronization techniques.
Linux High Availability provides concise summaries of key concepts:
- High availability (HA) clustering allows services to take over work from others that go down, through IP and service takeover. It is designed for uptime, not performance or load balancing.
- Downtime is expensive for businesses due to lost revenue and customer dissatisfaction. Statistics show significant drops in availability even at 99.9% uprates.
- To achieve high availability, systems must be designed with simplicity, failure preparation, and reliability testing in mind. Complexity often undermines reliability.
- Myths exist around technologies like virtualization and live migration providing complete high availability solutions. True HA requires eliminating all single points of
This document introduces PyOpenCL and provides examples for using it to perform GPU computing via Python. It begins with an overview of GPU computing and OpenCL. It then discusses setting up the PyOpenCL environment on different platforms like Windows, MacOS, and Linux. Examples shown include printing "Hello Taiwan" on the GPU, performing arithmetic operations on arrays in parallel, and image processing tasks like grayscale conversion and blurring using OpenCL data types and memory models. Atomic functions and synchronization are also covered.
The lecture by Norman Feske for Summer Systems School'12.
Genode Compositions
SSS'12 - Education event, organized by ksys labs[1] in 2012, for students interested in system software development and information security.
Genode[2] - The Genode operating-system framework provides a uniform API for applications on top of 8 existing microkernels/hypervisors: Linux, L4ka::Pistachio, L4/Fiasco, OKL4, NOVA, Fiasco.OC, Codezero, and a custom kernel for the MicroBlaze architecture.
1. http://ksyslabs.org/
2. http://genode.org
Decoupling Provenance Capture and Analysis from ExecutionPaul Groth
Presentation for the paper:
Manolis Stamatogiannakis, Paul Groth and Herbert Bos. Decoupling Provenance Capture and Analysis from Execution
Presented at Theory and Practice of Provenance 2015 (TaPP'15)
http://workshops.inf.ed.ac.uk/tapp2015/
The document discusses the Post Memory Corruption (PMCMA) tool, which allows analyzing memory corruption bugs by testing different memory overwrite scenarios in a process. PMCMA uses a technique called "mk_fork()" to efficiently fork a process multiple times and overwrite different memory locations in each offspring to test for exploitation possibilities. It discusses challenges like dealing with zombie processes and invalid system calls caused by forking, and how PMCMA addresses these through techniques like process grouping and ignoring SIGCHILD signals.
This document discusses improvements made to LXC container support in Ganeti through a Google Summer of Code project. Key areas worked on included fixing existing LXC integration, adding unit tests, setting up quality assurance, and adding features like migration. The project was mentored by Hrvoje Ribicic. Future work may include two-level isolation of containers within VMs and live migration of LXC instances.
XDP in Practice: DDoS Mitigation @CloudflareC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2NtlaER.
Gilberto Bertin discusses the architecture of Cloudflare’s automatic DDoS mitigation pipeline, the initial packet filtering solution based on Iptables, and why Cloudflare had to introduce userspace offload. Bertin also describes how they switched from a proprietary offload technology to XDP for network stack bypass and how they are using XDP to load balance traffic. Filmed at qconlondon.com.
Gilberto Bertin works as a System Engineer at Cloudflare London. After working on variety of technologies like P2P VPNs and userspace TCP/IP stacks, he joined the Cloudflare DDoS team in London to help filter all the bad internet traffic.
HES2011 - Sebastien Tricaud - Capture me if you canHackito Ergo Sum
The document discusses techniques for capturing network traffic and system logs to detect security incidents in large networks. It describes how to capture traffic using libpcap, nfqueue, and DAQ. It also discusses challenges like fragmentation and the need to decode protocols. For logs, it highlights weaknesses like signature-based detection and the importance of normalized, unconfigurable logs. It introduces CUDA and NetGPU for GPU-accelerated traffic processing and visualization tools like SecViz and Circos for analyzing large datasets. The conclusion emphasizes that visualization can help solve the problem of events getting lost in noise and overcome technical limitations of current detection approaches.
Hackito Ergo Sum 2011: Capture me if you can!stricaud
This document discusses capturing network traffic and logs to find security incidents. It describes how to capture traffic using libpcap and nfqueue. It also discusses challenges like fragmentation. For logs, it notes they are important for forensics but can be weakened by configurable log formats. Normalization of logs is important for analysis but the format can be exploited. There is no database of log misuse vulnerabilities.
This document discusses optimizing AES encryption algorithms for GPU architectures. It presents three optimization approaches: 1) storing Sbox tables in constant memory, 2) caching Sbox tables in local memory, and 3) overlapping kernel execution with I/O using multiple command queues. Optimization 2 improved performance on an AMD iGPU from 100MB/sec to 210MB/sec. Optimization 3 improved performance further by overlapping computation and I/O. The conclusions recommend caching over constant memory, overlapping execution with I/O, and note iGPU AES performance will continue increasing with each new generation.
This document provides instructions for creating an alternative cryptocurrency like Bitcoin. It outlines the necessary planning steps like designing coin parameters, source code configuration changes, and compiling the code. Key steps include cloning an existing altcoin source, modifying parameters like block time and total coin amount, generating a genesis block, and connecting multiple computers to mine fresh coins. The document cautions that one should not create an altcoin just for the sake of it, but instead focus on innovation through new hashing algorithms, economic models, or smart contract capabilities.
This document discusses Linux kernel debugging. It provides an overview of debugging techniques including collecting system information, handling failures, and using printk(), KGDB, and debuggers. Key points covered are the components of a debugger, how KGDB can be used with gdb to debug interactively, analyzing crash data, and some debugging tricks and print functions.
CSW2017Richard Johnson_harnessing intel processor trace on windows for vulner...CanSecWest
This document discusses using Intel Processor Trace (Intel PT) for hardware-based tracing on Windows. It provides an overview of Intel PT capabilities and how it can be used for fuzzing and vulnerability discovery. Specifically, it describes the development of WinAFL IntelPT, which integrates Intel PT tracing with the WinAFL evolutionary fuzzer to enable high-performance, hardware-driven fuzzing on Windows.
Similar to Improving the Scalability of Transparent Checkpointing for GPU Computing Systems (20)
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.
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"Choosing proper type of scaling", Olena SyrotaFwdays
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
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.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/how-axelera-ai-uses-digital-compute-in-memory-to-deliver-fast-and-energy-efficient-computer-vision-a-presentation-from-axelera-ai/
Bram Verhoef, Head of Machine Learning at Axelera AI, presents the “How Axelera AI Uses Digital Compute-in-memory to Deliver Fast and Energy-efficient Computer Vision” tutorial at the May 2024 Embedded Vision Summit.
As artificial intelligence inference transitions from cloud environments to edge locations, computer vision applications achieve heightened responsiveness, reliability and privacy. This migration, however, introduces the challenge of operating within the stringent confines of resource constraints typical at the edge, including small form factors, low energy budgets and diminished memory and computational capacities. Axelera AI addresses these challenges through an innovative approach of performing digital computations within memory itself. This technique facilitates the realization of high-performance, energy-efficient and cost-effective computer vision capabilities at the thin and thick edge, extending the frontier of what is achievable with current technologies.
In this presentation, Verhoef unveils his company’s pioneering chip technology and demonstrates its capacity to deliver exceptional frames-per-second performance across a range of standard computer vision networks typical of applications in security, surveillance and the industrial sector. This shows that advanced computer vision can be accessible and efficient, even at the very edge of our technological ecosystem.
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots - like ChatGPT - can converse on any topic, task-oriented chatbots - the focus of this paper - are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.
To fill this gap, we propose adapting mutation testing (MuT) for task-oriented chatbots. To this end, we introduce a set of mutation operators that emulate faults in chatbot designs, an architecture that enables MuT on chatbots built using heterogeneous technologies, and a practical realisation as an Eclipse plugin. Moreover, we evaluate the applicability, effectiveness and efficiency of our approach on open-source chatbots, with promising results.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Choosing The Best AWS Service For Your Website + API.pptx
Improving the Scalability of Transparent Checkpointing for GPU Computing Systems
1. Improving the Scalability of Transparent
Checkpointing for GPU Computing Systems
The 2012 IEEE Region 10 Conference
(TENCON 2012)
Cebu, Philippines
November 21, 2012
Alfian Amrizal, S. Hirasawa, K. Komatsu, H. Takizawa, H. Kobayashi
Tohoku University
2. Outline
• Introduction
• Two-level CheCL
• Performance Model
• Evaluation and Discussion
• Conclusion
2
3. High-Performance Computing & Checkpoint
• High-performance computing (HPC) systems are getting faster
and larger in scale
– Consist of huge numbers of CPUs and GPUs
– Probability of encountering failures also increases
• Checkpoint/restart (CPR) tools are important to make sure
HPC systems can successfully finish their calculation
– Long running applications; e.g. SPECFEM3D
CPU-GPU in Heterogeneous HPC system
3
4. Difficulties in CPR of Heterogeneous Systems
• Heterogeneous systems use both CPUs and GPUs
• Conventional CPR tools such as BLCR and DMTCP do not
assume GPUs ⇒ CPR fails
compute node CPU GPU
SCR_Start_checkpt();
SCR_Route_file(fn,fn2);
…
fwrite(data,…);
Host
…
Device
SCR_Complete_checkpt();
Memory Memory
process resource
conventional CPR tools CheCL allows conventional
only save CPU state tools to save GPU state
• CheCL has been developed for checkpointing OpenCL
applications running on CPU-GPU systems [Takizawa, IPDPS’11]
4
5. Difficulties in CPR of Heterogeneous Systems
• Problem: checkpointing time increases with the # of nodes
5
6. Writing Checkpoints to Global Storage is Ineffective
• To withstand failures, large-scale heterogeneous systems need
to checkpoint more frequently to the global storage (low BW)
• However, the global storage is shared among nodes
⇒ CheCL ‘s checkpoint time increases with the # of nodes
• CheCL is not scalable: the larger the node’s numbers, the
SCR_Start_checkpt();
SCR_Route_file(fn,fn2);
…
fwrite(data,…);
…
SCR_Start_checkpt();
SCR_Route_file(fn,fn2);
…
fwrite(data,…);
…
SCR_Start_checkpt();
SCR_Route_file(fn,fn2);
…
fwrite(data,…);
…
SCR_Start_checkpt();
SCR_Route_file(fn,fn2);
…
fwrite(data,…);
…
compute nodes it takes to checkpoint
longer
SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt();
• Objective
– To establish an effective implementation of the checkpointing
mechanism for heterogeneous HPC system
Network Contention
global storage 6
7. Writing Checkpoints to Global Storage is Ineffective
• To withstand failures, large-scale heterogeneous systems need
to checkpoint more frequently to the global storage (low BW)
• However, the global storage is shared among nodes
⇒ CheCL ‘s checkpoint time increases with the # of nodes
• CheCL is not scalable: the larger the node’s numbers, the
longer it takes to checkpoint
• Objective
– To establish an effective implementation of the checkpointing
mechanism for heterogeneous HPC system
7
8. Outline
• Introduction
• Two-level CheCL
• Performance Model
• Evaluation and Discussion
• Conclusion
8
9. Local CheCL
• Avoid the network by utilizing node’s local storage
– Simultaneous checkpointing → Fast
– Less reliable
SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt();
SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2);
… … … …
fwrite(data,…); fwrite(data,…); fwrite(data,…); fwrite(data,…);
… … … …
SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt();
compute nodes
Add local storage to Interrupt this process
each node
Large, reliable but slow 9
global storage
10. Local CheCL
• Avoid the network by utilizing node’s local storage
– Simultaneous checkpointing → Fast
– Less reliable
SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt();
SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2);
… … … …
fwrite(data,…); fwrite(data,…); fwrite(data,…); fwrite(data,…);
… … … …
SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt();
compute nodes
Add local storage to
each node
Large, reliable but slow 10
global storage
11. Local CheCL
• Avoid the network by utilizing node’s local storage
– Simultaneous checkpointing → Fast
– Less reliable
SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt();
SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2);
… … … …
fwrite(data,…); fwrite(data,…); fwrite(data,…); fwrite(data,…);
… … … …
SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt();
compute nodes
Add local storage to
each node
Large, reliable but slow 11
global storage
12. Two-level CheCL
• Writing ckpt files to the global storage is more reliable but time
consuming
• Use local storages of compute nodes. Fast but sacrifice reliability
Propose Two-level CheCL : use both local and global ⇒ Local CheCL + Global CheCL
SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt(); SCR_Start_checkpt();
SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2); SCR_Route_file(fn,fn2);
… … … …
fwrite(data,…); fwrite(data,…); fwrite(data,…); fwrite(data,…);
… … … …
SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt(); SCR_Complete_checkpt();
compute nodes
local storages
shared global storage
12
13. Outline
• Introduction
• Two-level CheCL
• Performance Model
• Evaluation and Discussion
• Conclusion
13
14. Performance Model
• Total execution time of an OpenCL application running with
Two-level CheCL is Ttotal
• The original execution time is Ts
n dG n n dL n dL n
Ts
14
16. Performance Model
• Total time spent for checkpointing is TC
• Local CheCL ckpt overhead CL, Global CheCL ckpt overhead CG
75% 25%
n CG n CL n CL n CL n
Ts + Tc
16
17. Performance Model
• No failure during ckpt process. On average, failures occur at 0.5n
• TL is time overhead when the process is recoverable by the latest
checkpoint file.
0.5n 0.5n 0.5n 0.5n 0.5n
n CG n CL n CL n CL n
Ts + Tc
17
18. Performance Model
• No failure during ckpt process. On average, failures occur at 0.5n
• TL is time overhead when the process is recoverable by the latest
checkpoint file.
wasted time 85% 15%
# of failures [Moody, SC’10]
n CG n CL 0.5n
RL n CL n
n CG 0.5n
RG n CL n CL n
18
19. Performance Model
• TG is time overhead when the process is only recoverable by the
global checkpoint file.
n CG n CL 0.5n
RG RL n CL n
19
20. Outline
• Introduction
• Two-level CheCL
• Performance Model
• Evaluation and Discussion
• Conclusion
20
21. Experimental Set Up
• The evaluation was conducted on a GPU cluster of
four compute nodes, each compute node has:
– Intel core i7 930 CPU
– Nvidia Tesla C2070 GPU
– Main memory of 24 GB
– tmpfs RAM Disk of 12 GB
• CPR tools:
– BLCR-0.8-4 (CPU state ckpt)
– CheCL (GPU state ckpt)
• Benchmark:
– Molecular Dynamic (MD)
21
22. Checkpoint Time Comparison for GPU Cluster
16000
Accelerate up to > 4x
14000
Checkpoint Time (ms)
12000
10000
8000
6000 Global CheCL
Local CheCL
4000
2000
0
12288 24574 73728 12288 24574 73728 12288 24574 73728
1 node 2 nodes 4 nodes
# of Nodes and Problem size
22
23. Efficiency (Ts/Ttotal) Improvement (No Failure)
100%
Two-level CheCL’s PL:PG=3:1
90%
80%
70%
Efficiency
60%
50%
40%
30%
20%
10%
0%
1x 2x 4x 8x 16x 32x 64x
Checkpoint Frequencies
2 nodes, Local and Global 2 nodes, Global only 4 nodes, Local and Global 4 nodes, Global only
23
24. Efficiency Improvement (MTTF = 3 minutes)
[Schroeder, SciDAC’07]
100%
Two-level CheCL’s PL:PG=3:1
90%
80%
70%
Efficiency
60%
50%
40%
30%
20%
10%
0%
1x 2x 4x 8x 16x 32x 64x
Checkpoint Frequencies
4 nodes, Local and Global 4 nodes, Global only
24
25. Trade-off Between Local/Global Ratio and Two-level CheCL’s Time Overhead
4500
4000
3500
Time overhead (ms)
3000
2500
2000
1500
1000
500
0
(0:10) (1:9) (2:8) (3:7) (4:6) (5:5) (6:4) (7:3) (8:2) (9:1)
Local/Global ratio
25
26. Conclusion
• Checkpointing is important for HPC system
dependability
• Two-level CheCL can improve system efficiency
• Local CheCL can be used for high speed
checkpointing
• There is a trade-off between Local and Global CheCL
which must be treated carefully for future
implementation on large-scale GPU computing
systems
26