The Linux perf tool was originally written to allow access to the performance monitoring hardware that counts hardware events, such as instructions executed, processor cycles, and cache misses. However, it can also be used to count software events, which can be useful in gauging how frequently some part of the system software is executed.
Recently someone at Red Hat asked whether there was a way to get a count of system calls being executed on the system. The kernel has a predefined software trace point,
raw_syscalls:sys_enter, which collects that exact information; it counts each time a system call is made. To use the trace point events, the
perf command needs to be run as root.
Continue reading “How to use the Linux perf tool to count software events”
Since starting to update my free online rules and process automation workshops that showcase how to get started using modern business logic tooling, we’ve come a long way with process automation. The updates started with moving from JBoss BPM to Red Hat Decision Manager and from JBoss BPM Suite to Red Hat Process Automation Manager.
The first lab update showed how to install Red Hat Decision Manager on your laptop, and the second lab showed how to create a new project. This article highlights the newest lab update for Red Hat Process Automation Manager, where you’ll learn how to create a domain model.
Let’s take a look at the lab, shall we?
Continue reading “Modern business logic tooling workshop, lab 3: Create a domain model”
In Part 6 of this series, we looked into details that determine how your integration becomes the key to transforming your customer experience. It started with laying out the process of how I’ve approached the use case by researching successful customer portfolio solutions as the basis for a generic architectural blueprint.
Having completed our discussions on the blueprint details, it’s time to look at a few specific examples. This article walks you through an example integration scenario showing how expanding the previously discussed details provides blueprints for your own integration scenarios.
Continue reading “Integration blueprint example for process automation (part 7)”
One of the most important concepts introduced in C++11 was move semantics. Move semantics is a way to avoid expensive deep copy operations and replace them with cheaper move operations. Essentially, you can think of it as turning a deep copy into a shallow copy.
Move semantics came along with several more or less related features, such as rvalue references, xvalues, forwarding references, perfect forwarding, and so on. The standard C++ library gained a function template called
std::move, which, despite its name, does not move anything.
std::move merely casts its argument to an rvalue reference to allow moving it, but doesn’t guarantee a move operation. For example, we can write a more effective version of
void swap(T& a, T& b)
T t(std::move (a));
a = std::move (b);
b = std::move (t);
This version of swap consists of one move construction and two move assignments and does not involve any deep copies. All is well. However,
std::move must be used judiciously; using it blithely may lead to performance degradation, or simply be redundant, affecting readability of the code. Fortunately, the compiler can sometimes help with finding such wrong uses of
std::move. In this article, I will introduce two new warnings I’ve implemented for GCC 9 that deal with incorrect usage of
Continue reading “Understanding when not to std::move in C++”
A common question that SystemTap can be used to answer involves how often particular events occur on the system. Some events, such as system calls, can happen frequently and the goal is to make the SystemTap script as efficient as possible.
Using the statistical aggregate in the place of regular integers is one way to improve the performance of SystemTap scripts. The statistical aggregates record data on a per-CPU basis to reduce the amount of coordination required between processors, allowing information to be recorded with less overhead. In this article, I’ll show an example of how to reduce overhead in SystemTap scripts.
Continue reading “Speed up SystemTap scripts with statistical aggregates”
The mental model most people have of how computer memory (aka Random Access Memory or RAM) operates is inaccurate. The assumption that any access to any byte in memory has the same low cost does not hold on modern processors. In this article, I’ll explain what developers need to know about modern memory and how data layout can affect performance.
Current memory is starting to look more like an extremely fast block storage device. Rather than reading or writing individual bytes, the processor is reading or writing groups of bytes that fill a cache line (commonly 32 to 128 bytes in size). An access to memory requires well over a hundred clock cycles, two orders of magnitude slower than executing an instruction on the processor. Thus, programmers might reconsider the data structures used in their program if they are interested in obtaining better performance.
Continue reading “How data layout affects memory performance”
This article series shows how to get started using modern business logic tooling. These updates start with moving from JBoss BPM to Red Hat Decision Manager and from JBoss BPM Suite to Red Hat Process Automation Manager.
The first lab update showed how to install Red Hat Decision Manager on your laptop. This article highlights the second lab update for Red Hat Process Automation Manager, which shows how to create a new project.
Let’s take a look at the lab, shall we?
Continue reading “Modern business logic tooling workshop, lab 2: Create a new project”
We are extremely pleased to announce that the preview release of the Red Hat OpenShift Connector for JetBrains products (IntelliJ IDEA, WebStorm, etc.) is now available in Preview Mode and supports Java and Node.js components. You can download the OpenShift Connector plugin from the JetBrains marketplace or install it directly from the plugins gallery in JetBrains products.
In this article, we’ll look at features and benefits of the plugin and installation details, and show a demo of how using the plugin improves the end-to-end experience of developing and deploying Spring Boot applications to your OpenShift cluster.
Continue reading “What Red Hat OpenShift Connector for JetBrains products offers developers”
Although containers and Kubernetes and microservices seem to come up in every conversation, there’s a big chasm between talking about, demonstrating, and actually using a technology in production. Anyone can discuss containers, many people can demo them, but far fewer are successfully using containers and Kubernetes in a microservices architecture.
Why? There are likely many reasons, but a simple one may be that developers don’t know where to start.
Consider this series of articles your starting point. Relax, read on, and get ready to enter the exciting world of containers, Kubernetes, and microservices.
Continue reading “Containers, Kubernetes, and microservices: Start here”
Knative is not just a hot topic in software development, it’s a whole new way to look at services and functions. As a developer, what do you need to know to take advantage of this cutting-edge technology? Are there important design or implementation considerations? Let’s take a look.
Continue reading “Knative: What developers need to know”