Ivan Savu’s Post

In the pursuit of top-notch database performance, every millisecond counts. At VeloxDB, we take optimizing garbage collection very seriously. Here's why and how: Garbage collection isn't free - When you are processing millions of transactions, every CPU clock counts. By taking control of memory management, we relieve GC, leaving more CPU time for transaction processing. We understand our data better than any generic garbage collector ever could. We know that: - Committed data is likely to be long-lived - We can precisely determine when data is safe to discard This knowledge allows us to make smarter, more efficient memory management decisions. The results speak for themselves. Take a look at the attached image - it shows the CPU usage of Garbage Collector threads during our performance benchmark. While VeloxDB processes nearly a million transactions per second, the Garbage Collector remains virtually idle. This is a testament to the efficiency of our memory management approach. By taking control of our memory management, we've been able to significantly boost VeloxDB's performance while still leveraging the strengths of the .NET ecosystem. It's this kind of low-level optimization that allows us to deliver the speed and efficiency our users expect from a high-performance database. #VeloxDB #DotNet #MemoryManagement

SPTP can offer the exact same level of synchronization with a lot fewer resources consumed, in a large-scale data center deployment, it can help to combat frequently changing network paths and create savings in terms of network traffic, memory usage, and number of CPU cycles.

🚀 Optimizing Database Performance: Faster CPU or More Cores? As a Database Specialist at a software development company, we faced a significant challenge: system slowdowns that needed in-depth investigation. Here’s how we tackled the issue and made decisions on whether to upgrade our CPU’s frequency or increase the number of cores. 🔍 Key Metrics Analyzed: To pinpoint the issue and make an informed decision, we reviewed the following parameters in Performance Monitor: ParameterObserved Value % Processor Time : 85% Processor Queue Length :12 %User Time: 65% % Privileged Time :25% Interrupts/sec :1500 DPCs Queued/sec :1800 📈 Analysis: The metrics indicated that our CPU was under significant stress: % Processor Time was high (85%) and Processor Queue Length was elevated (12), signaling excessive CPU load. % User Time (65%) and % Privileged Time (25%) showed a high workload from both user and system processes. Interrupts/sec and DPCs Queued/sec were in the moderate range, indicating additional load. 💡 Decision-Making: Given that % Processor Time and Processor Queue Length were at these levels (85% and 12), we decided to increase the CPU frequency. If Processor Queue Length and % Processor Time had consistently been higher than 10 and 80%, respectively, we would have opted to increase the number of CPU cores instead. In this case, based on the metrics, we chose to upgrade to a higher-frequency CPU, which effectively resolved the performance issues. I hope this experience proves useful to you as well. Feel free to share your questions or similar experiences in the comments! #PerformanceMonitoring #DatabaseOptimization #CPU #ITManagement #TechInsights

Some of the 16 key metrics to measure system performance I was reading about. 1. Throughput: The rate at which the system processes requests, often measured in transactions per second (TPS) or requests per second (RPS). 2. Latency: The time taken for a request to be processed and a response returned, typically measured in milliseconds (ms). 3. P95 (95th Percentile Latency): The latency below which 95% of requests fall, providing insight into worst-case performance. 4. Error Rate: The percentage of requests that result in errors. 5. Queue Length: The number of requests waiting to be processed, indicating potential bottlenecks. 6. Load Average: The average number of processes waiting to be executed, indicating the overall system load. 7. Cache Hit Ratio: The percentage of requests served from the cache rather than the primary storage. 8. Thread Count: The number of active threads, indicating the level of concurrency. 9. Swap Usage: The amount of memory being used from the swap space, which can indicate memory pressure. 10. Database Query Time: The average time it takes to execute database queries. 11. Database Session Count: The number of active sessions or connections to the database at a given time. 12. CPU Utilisation: The percentage of CPU capacity currently being used by the system. 13. Memory Utilisation: The percentage of available memory being used by the system. 14. Disk I/O: The rate of read and write operations on the storage subsystem, typically measured in operations per second. 15. Network I/O: The amount of data being sent and received over the network, often measured in bytes per second. 16. Context Switches: The rate at which the CPU switches between threads or processes, impacting performance.

An Insightful Read on Database Reactivity and the Change Data Capture (CDC) Process #reactivecomputing #cdc #changedatacapture #redis #dicedb #realtime Dice DB Reactivity: https://lnkd.in/gHRyfeWC CDC: https://lnkd.in/gJjsdS7p

Based upon an old calculation I made few years back and considering there are roughly 25,0000 credit card transactions per second world wide - my old 2008 workstations can handle the following maybe the rejects are just screwing up IT infrastructure world wide but here goes : I think IT may actually be paying a lot of people for not a lot ! The throughput of Kafka can vary based on several factors, including hardware specifications, network bandwidth, Kafka configuration, and the nature of the workload. However, Kafka is known for its high throughput and can handle millions of messages per second under optimal conditions. Key Factors Affecting Kafka Throughput Hardware Specifications: CPU, memory, disk I/O, and network bandwidth. Kafka Configuration: Number of partitions, replication factor, batch size, and compression. Network Bandwidth: The speed and reliability of the network connecting the API gateways and Kafka brokers. Message Size: The size of each message being sent to Kafka. Estimating Throughput Given the following assumptions: Each API record is 1.5 KB. You have 5 Dell Precision T7500 machines with 192 GB memory each. Kafka is running on these machines. You have 3 API gateways sending data to Kafka. Kafka Throughput Estimation Hardware Specifications: Dell Precision T7500 with 192 GB memory. Assume each machine has a high-performance SSD and a 10 Gbps network interface. Kafka Configuration: Number of partitions: More partitions can increase parallelism and throughput. Replication factor: Higher replication factor provides fault tolerance but can reduce throughput. Batch size and compression: Larger batch sizes and compression can improve throughput. Network Bandwidth: Assume a 10 Gbps network interface. Calculating Theoretical Throughput Network Bandwidth: 10 Gbps = 10,000 Mbps = 1,250 MB/s per machine. With 5 machines, total network bandwidth = 1,250 MB/s * 5 = 6,250 MB/s. Message Size: Each message is 1.5 KB = 0.0015 MB. Theoretical Maximum Throughput: Total messages per second = Total network bandwidth / Message size. Total messages per second = 6,250 MB/s / 0.0015 MB = 4,166,667 messages per second. Practical Considerations Replication Factor: If the replication factor is 3, each message is written to 3 brokers, reducing effective throughput. Effective throughput = Theoretical throughput / Replication factor. Effective throughput = 4,166,667 / 3 ≈ 1,388,889 messages per second. Kafka Overhead: Kafka has some overhead for managing partitions, leaders, and followers. Assume a 20% overhead for Kafka management. Effective throughput after overhead = 1,388,889 * 0.8 ≈ 1,111,111 messages per second.

Is programmers' time more valuable than server time? 🕒🗄️ Ionuta Balosin, known for his performance experiments with #JVM, investigated energy consumption patterns in various JVMs. To do this, he used command-line tools such as "powerstat" and "powermetrics," as well as physical measurement devices (power meters connected to sockets), which allowed him to assess JVM performance on different architectures. The research results were not revolutionary but revealed several interesting observations. For example, #Oracle GraalVM Native Image, especially when optimized for PGO (Profile-Guided Optimization), showed a favorable balance between #energyefficiency and performance, highlighting the potential benefits of Ahead-of-Time Compilation to reduce #energy consumption during runtime. The entire #experiment demonstrated the complexity of the relationship between energy consumption and performance in different JVMs and types of #applications, due to the vast number of moving parts. However, drawing conclusions about energy efficiency is challenging because the most energy-efficient JVM in one scenario may not be so in other conditions or with different types of #applications. In summary, while the experiment itself was interesting, it did not yield any groundbreaking insights into our #IT world.

Ever found yourself waiting endlessly for data to load? Or perhaps your application crashes under heavy load, leaving users frustrated? We’ve all been there. Without caching, these issues can become a recurring nightmare. Without caching, every data request hits the primary database or storage. This leads to: - Slower Response Times: Every request has to traverse the full path to fetch data, resulting in sluggish performance. - High Latency: Frequent database queries can slow down your system, making users wait longer. - Increased Load on Servers: With every request reaching the server, the load increases, leading to potential crashes and downtime. - Costly Operations: More server resources and bandwidth are consumed, leading to higher operational costs. Caching can be a game-changer for your system. It’s all about storing copies of frequently accessed data in a temporary storage location, allowing future requests to be served faster. Why Cache? - Speed Up Data Retrieval: Cache stores data in-memory, significantly reducing access time. - Reduce Server Load: Offload frequent queries from your primary database, leading to better scalability. - Cost Efficiency: Decrease resource consumption, saving costs on server operations. - Improve User Experience: Faster load times and improved application reliability make for happy users. Dive into my full article where I break down the different types, strategies, and best practices for implementing caching effectively.

Visual representation of a server metrics collecting system in a large scale distributed system. The system is supposed to collect system data such as CPU, Memory usage etc in real time and analyze the huge data received. This design is based on push model where the data from the server is pushed by a background process, periodically to the processing sub system. The data is then stored in a time series database that can be used for further processing. Pros of Push Model: * Pushing data to a message queue helps scale the amount of data that can be handled. * No additional controller is required to know from which server the data needs to be pulled. Cons of Push Model: * There is some workload on the servers from which the metrics is collected because of a background process running periodically to push data * Chances of Duplicate data is higher, but this is tunable. * Using message queue like Kafka adds complexity and is difficult to maintain. #TechBytes #technology #largescalesystem #distributedsystem #pushdata #systemdesign

How to monitor & tune pureScale, compared to ESE?(DB2 LUW Purescale) Most things to monitor and tune in pureScale are the same as for DB2 EE • CPU usage, SQL access plans, package cache activity, lock waits, deadlocks, sorting, I/O times, logging, etc. • The same monitoring interfaces (MON_GET_xxx table functions, monreport.dbsummary, Optim Performance Manager, etc.) are already tooled‐up for pureScale A few things to keep an eye on in pureScale: 1. Cluster interconnect utilization 2. Page reclaims 3. Group bufferpool activity 4. CF utilization 1. Cluster Interconnect Utilization : Message response time between the members and the CFs is key to great pureScale performance.If the interconnect becomes a bottleneck, overall cluster performance will suffer.We can monitor this with MON_GET_CF_CMD table function. If this is the issue then Reduce message traffic (disable autocommit? reduce isolation level?)Add an extra interconnect adapter to the CF?. 2.Page reclaims : Preemptively moving a page from one member that's updating it to another member that needs it can help overall concurrency, but it's an expensive operation . In extreme cases, 'thrashing' of pages between members can hurt overall performance.MON_GET_PAGE_ACCESS_INFO table function can be used to monitor. 3. Group bufferpool (GBP) activity : The GBP contains modified pages from the committed transactions before they're written to disk, and a list of all pages in all cluster members. MON_GET_BUFFERPOOL provides pureScale GBP metrics to calculate H/R (pool_data_gbp_l_reads – pool_data_gbp_p_reads) / pool_data_gbp_l_reads • If  pool_data_l_reads > 10 x pool_data_gbp_l_reads then GBP isn't being used that much – don't worry about a low GBP H/R • If  pool_data_gbp_invalid_pages > 25% of pool_data_gbp_l_reads then GBP is helping out, so making it big enough to get a good H/R is worthwhile • MON_GET_GROUP_BUFFERPOOL has one very helpful metric • Num_gbp_full indicates how often the GBP ran out of available pages 4) Cluster Caching Facility (CF) utilization: CF response time is key for overall cluster performance. Interconnect is the main thing, but we also want to keep an eye on CF CPU utilization. • Difficulty: vmstat & other O/S level tools see ~100% CPU usage on the CF, even when the cluster is idle • Admin view ENV_CF_SYS_RESOURCES gives a good picture of how busy the CF really is