The 95th Percentile

Imagine a reality, where you can detect and fix issues without your users noticing that something went wrong.

We all aspire to measure performance in some way, and choosing what to measure can be a challenge in itself. By default, we think about averages, and we forget that there are many other possible measurements.

Data Locality is Important

Never would have imagined that the laws of physics would be so important in a world where virtualization is the new normal.

Data Locality, refers to the ability to move the computation close to the data. This is important because when performance is key, IO quickly becomes our number one bottleneck. Data access times vary from milliseconds to seconds because of many factors like hardware specifications and network capabilities.

Let’s explore Data Locality through the following Scenario. I have eight files containing data about multiple trucks, and I need to Identify trips. A trip consists of many segments, including short stops. So if the driver stops for coffee and starts again, this is still considered the same trip. The strategy depicted below is to read each file and to group data points by truck. This can be referred to as mapping the data. Then we can compute the trips for each group in parallel over multiple threads. This can be referred to as reducing the data. And finally, we merge the results in a single CSV file so that we can easily import it to other systems like SQL Server and Power BI.

The single machine configuration results were promising. So I decided to break it apart and distribute the process across many task Virtual Machines (TVM). Azure Batch is the perfect service to schedule jobs.

One Petaflop

In recent discussions around big compute I was asked what a Petaflop (PFlop) would look like on Azure. Now, I had heard the term before and knew it was used to describe a considerable capacity of compute. So what is a petaflop (PFlop) and how do we convert this into something that we can all relate to?

Releasing Memory Pressure

Traditionally, in .NET applications we adjust the Garbage Collector to operate in server mode by modifying the App.config or Web.config files. However, Worker Roles work differently because your code is actually hosted by the WaWorkerHost.exe process. So you must modify the WaWorkerHost.exe.config file instead of app.config and web.config.

This article covers the Worker Role. However, the same concepts and techniques may be used to change the Web Roles mode by changing WaWebHost.exe.config instead of WaWorkerHost.exe.config.

WaWorkerHost.exe.config is in %approot%\base\x64

What is ServerGC & Why is it Important?

The Server Garbage Collection process allows us to reclaims objects that are no longer being used, clears memory, and makes it available for future allocations. In contrast to the Work Station Garbage Collector mode, the Server Garbage Collection mode aggressively releases memory and can prevent your roles from running out of memory due to memory bloat.

Reducing memory bloat allows us to increased density, which typically reduces overall operational costs in a pay for what you consume environment. Furthermore, Background Server Garbage Collection can increase performance.

Conditions for a Garbage Collection Include

• The system has low physical memory.
• The memory that is used by allocated objects on the managed heap surpasses an acceptable threshold. This threshold is continuously adjusted as the process runs.
• The GC.Collect method is called. In almost all cases, you do not have to call this method, because the garbage collector runs continuously. This method is primarily used for unique situations and testing.

Drive Productivity by Limiting Work in Progress

We were a team that finally worked as a team! Identifying and removing blocking issues from the work in progress (WIP) became everyone’s focus. Our communication improved and knowledge was shared. This resulted in more contributions from everyone on the team.

Continue Reading...

#WindowsAzure Lessons Learned : Be Stateful

I know… I know, these days we’re mostly talking about being stateless and there are valid reasons for it. But when we’re building Cloud Services where performance is critical, we need to think about state.

Let’s reflect on what it means to be stateful for a moment. Being stateful means that we keep data close to our processes. What it doesn’t mean, is that we should forget about persistence. That being said lets go over some of the reasons why much of the community is all about statelessness.

Indexes are Crucial on Azure SQL Database!

One of the issues that seem to come up time and time again, is the lack of a basic index strategy. Many Windows Azure SQL Databases fail under load because they lack indexes.

Continue Reading...

Steps Towards Optimized Azure SQL Databases

Azure SQL Database is a high density multi-tenant database service, whose performance is not guaranteed due to its nature. Thus, it’s imperative that we pay attention to details. This post is all about reviewing the structure and performance of existing Azure SQL Databases by giving you insights into what you should be looking for.

Prior to making any changes to your application, you should look into taking control of your database’s life cycle management by employing tools like the Microsoft SQL Server Data Tools. These tools allow you to target specific platforms like Azure SQL Database, which is very handy because it allows you to identify unsupported features before you deploy. Furthermore, they provide IntelliSense and make it possible to manage database versions by storing scripts in source control solutions like Microsoft Team Foundation Server.

Reaching Performance Targets on Azure by Preparing and Pre-Calculating Data

Azure is an amazing platform to work with! It creates interesting possibilities by offering a wide range of services that can be leveraged in order to produce exceptional end-user experiences.

Azure is built on commodity hardware and allows you to build elastic services that scale out in order to maintain a constant end-user experience. This is especially interesting when you want to start small and grow according to the demand for your services.

Enchanting as this may be, this is where many projects go wrong. Everything on the cloud has a price. On the cloud details matter! So choose the right architecture and be very cautious about the resources your application consumes.

Sharded Queue – Handling up to 60,000 Messages per Second

Windows Azure Storage Queues were designed with a performance target of 2,000 messages per second. I personally don’t see the queue’s performance target as a limitation. I see the queue as a partition that allows me to scale across logical and physical boundaries.

By scaling across many physical machines, the limitations imposed by the hardware becomes irrelevant.

This experiment has the goal of demonstrating how we can stitch together queues from multiple Windows Azure Storage Accounts in order to augment the maximum throughput of our Cloud Services.