The launch of Windows Azure has coincided with the launch of the entire cloud computing initiative from Microsoft which makes a lot of business sense but it also makes it hard to differntiate the individual parts of the initiative, here’s my understanding so far.

Windows Azure

This is the base platform that provides a generic cloud computing platform for developers to host applications on.  Azure basically offers two core services,

Compute Service

This is what people would normally associate with cloud computing. You write an app that conforms to the cloud hosting requirements and then deploy it to the cloud where it can be managed and scaled as per the load and performance requirements. Currently there are two types of compute services that can be deployed on Azure

Web Role - This currently is a WebForms ASP.Net application, but looks like support for ASP.Net MVC and other languages are in the works too. This is just like hosting your application with a hosting provider except that you get load balancing, failover etc. for free. One important caveat here is that the load balancing does not support sticky sessions(as of the CTP) which is a good thing but it does require the developer to use the storage service to store session data.

Worker Role - This is more like a Windows Service that is deployed on the cloud, it can make outgoing connections but incoming connections are disallowed. But again you get the benefits of load balancing and failover.

The compute services are different from other similar cloud computing options available because it does not require the developer to supply a VM image (unlike Amazon EC2) of the application environment to host,  instead the applications run in VMs that are built and maintained by the Microsoft Data Centers that host the applications.

This decision definitely has it pros and cons, it’s good because

- No licensing costs for the OS

- No need for updating of the VMs as the applications evolve

- Simpler deployment strategy

- API available for management of service instances and for reporting on application health

on the other hand

- it does restrict the flexibility of what software and services can be accessed from the host VM

This diagram from MSDN gives a nice overview

All though in reality the deployment internally looks like below with IIS7 and Windows Server 2008 VMs.

Azure Hosting

Storage Service

This is the second part of the base Azure platform and is the equivalent of Amazon S3, SQS and SimpleDB all rolled under one name. The equivalents in the Storage Service are called,

Blob - For storing binary data, most commonly file streams.

Queue  - For reliable persistent messaging. I found it strange that it was lumped with the storage services because the primary purpose of this seems to be inter service communication between the applications running in the cloud. 

Table - For storing tabular data, different from traditional database tables though.

The important thing to remember here is that these services are available to any application that can talk over HTTP so WPF, WinForms, and non-cloud ASP.Net applications can make use of the storage services as well and benefit from having their data stored in an easily scaled environment. The storage services expose a RESTFul API which makes it easy to access these services from any platform that can talk over HTTP but ofcourse if you’re using .Net you get some builtin support from the framework.

Azure Storage Services

The developer story for Windows Azure is as good as anything else from Microsoft, the SDK includes tools to simulate both the compute services and the storage services on your development box, further with the VS addin you can deploy your cloud application straight to the Azure hosting platform, talk about ease of deployment. Here’s a quick overview of the important tools included in the Azure SDK.

Development Fabric - Simulates the Azure Compute Services (aka Azure Fabric) on your dev machine complete with a load balancer and failover monitoring.

Development Storage - Simulates the Azure storage services on your dev machine, the CTP implmentation requires SQL Server 2008 Express but you can also work with SQL Server 2008 if you want.

CSPack - Command line tool that prepares a service for deployment either to the Development Fabric or to the Windows Azure Fabric.

CSRun - Command line tool that runs a service (generated from CSPack) on the Development Fabric.

So the development cycle for a Azure app consists of developing locally using the Development Fabric and Development Storage and then deploying to the Azure platform when ready.  Deployments would not normally bring down the sites because the instances are load balanced and are not sticky. 

The other good thing is that services can be configured manually be editing the service configuration file or programatically by accessing the ServiceHosting API at runtime, so no redeployment is required if only service configurations are changed (which includes things like number of instances to run).

That’s basically the core Azure platform, the rest of the stack (.Net Services, SQL Data Services and Live Services) are cloud applications built by Microsoft on top of the core Azure platform. Again all these applications expose their API in a RESTFul manner as well making them open to both any technology that can talk over HTTP.

Azure Services Platform

Personally for me the Windows Azure SDK section from MSDN and this document from David Chappel were the most useful pieces of documentation to understand the entire stack.

Here are the changes I had to make to get the samples and the SDK to work with SQLServer 2008 installed without an instance name on my laptop.

1. In Windows Azure SDK\v1.0\samples\MSBuild\Microsoft.Samples.ServiceHosting.targets , add the “/server” option to the UpdateSampleTablesDB target to make it look like

<Target Name=”UpdateSamplesTableDB” DependsOnTargets=”BuildSubProjects”>

    <Message Text=”$(DevTableGenCommand) /database:$(SamplesDBName) /server:localhost $(DevtableGenForceCreateFlag) @(DevTableGenAssemblies)”/>

    <Exec Condition=”‘$(SamplesDBName)’!=”” 

            Command=”$(DevTableGenCommand) /database:$(SamplesDBName) /server:localhost $(DevtableGenForceCreateFlag) @(DevTableGenAssemblies)” 

    WorkingDirectory=”$(MSBuildProjectDirectory)”/>

  </Target>

2. Change the datasource in the connection string used in  ”Windows Azure SDK\v1.0\bin\DevelopmentStorage.exe.config” to localhost

<connectionStrings>

    <add name=”DevelopmentStorageDbConnectionString”

         connectionString=”Data Source=localhost;Initial Catalog=DevelopmentStorageDb;Integrated Security=True”

         providerName=”System.Data.SqlClient” />

  </connectionStrings>

3. Change the dbServer for the Table service in the developmentStorageConfig section to localhost in “Windows Azure SDK\v1.0\bin\DevelopmentStorage.exe.config”

    <services>

      <service name=”Blob”

               url=”http://127.0.0.1:10000/”/>

      <service name=”Queue”

               url=”http://127.0.0.1:10001/”/>

      <service name=”Table”

               url=”http://127.0.0.1:10002/”

        dbServer=”localhost“/>

 

    </services>

HTH

My first stab at it consisted of a brute force solution of looking at every natural number up to a given limit and determining if the digits were unique, the crux of which was this function that given a number determined if the digits repeated or not

private static bool DoDigitsRepeat(long num) {
····//Used to track which digits have already been encountered
····int used = 0;
····while (num > 0) {
········int digit = (int)num % 10;
········num = num / 10;

········int index = 1 << digit;
········if ((used & index) == index) {
············return true;
········}
········else {
············used |= index;
········}
····}
····return false;
}

The good thing about this solution was that it met the secondary goal for the problem which was to determine the biggest gap in the sequence of generated numbers, but in terms of performance it sucked! It worked well for the smaller limits defined in the problem but when you tried to push and generate all matching numbers till the max possible i.e. 9876543210 it just took too long (I think it was under a minute, but that was still too long)

I went back to the problem page and saw that the scripting weenies who had tried to use string functions to prune numbers had the worst performance of all solutions, that made me feel a bit better until I saw CrazyBob’s Java solution(the fast version), the comments indicated that the solution found the total count in under half a second. This solution was not able to determine the biggest gap though because the numbers were generated out of order but nevertheless this was an excellent solution.

So began my quest to come up with a faster solution. I felt sure that I could use the bit twiddling hacks to come up with a faster solution, it was just a question of hitting the right spot.

The first non-brute force solution that I tried was to enumerate all possible subsets of {0,1,2,3,4,5,6,7,8,9} and then to generate permutations from that set making sure that zero was never in the first place. Subset generation is pretty easy to do, all you need to do is count from 0 to 2^n where n is the number of elements in the set, the bit patterns of all the numbers in this range can be used to generate all the subsets. For the first cut I tried to be Object-Oriented and used the below class to implement a BitTable.

public class BitTable
{
····private uint _storage = 0;
····public BitTable(uint value) {
········_storage = value;
····}

····public void Set(int index) {
········Debug.Assert(index >= 0 && index < 32);
········_storage |= (uint)(1 << index);
····}

····public void Reset(int index) {
········Debug.Assert(index >= 0 && index < 32);
········_storage &= (uint)~(1 << index);
····}

····public bool IsSet(int index) {
········Debug.Assert(index >= 0 && index < 32);
········uint val = (uint)(1 << index);
········return (_storage & val) == val;
····}
}

Of course as I soon found out, all the method calls to BitTable were really slowing things down (and by slow I mean a 1-2 seconds slower than CrazyBob’s solution), so I dropped the class and moved all the operations inline, also I realized that since I was using value types to hold the state in the search/call tree, I didn’t need to set and unset the state after each recursive call. Here’s the final version of this line of thinking.

class Beust4
{
private static int _total = 0;
public static void Run() {
····_total = 0;
····//Generate all possible subsets of a set of 10 elements
····//2^10 = 1024
····for (int i = 1; i <= 1024; ++i) {
········Permute(i, 0L);
····}

····Console.WriteLine("nTotal: {0}", _total);
}

private static void Permute(int digits, long current) {
····for (int index = (current > 0) ? 0 : 1; index <= 9; ++index) {
········if ((digits & (1 << index)) == (1 << index)) {
············if ((digits & ~(1 << index)) == 0) {
················//Console.Write("{0}, ", (current * 10) + index);
················++_total;
················return;
············}
············else {
················Permute(digits & ~(1 << index), (current * 10) + index);
············}
········}
····}
}

I felt really good about this attempt but to my surprise when I ran it, I took 1.2 seconds on average which was still more than 2 times slower than CrazyBob’s Java solution. I got really stuck at this point and I had to make sure that there was not something obvious that I was missing. The first thing I did was to port CrazyBob’s solution to .Net so that I could compare both solutions, I’ve uploaded the C# version of CrazyBob’s solution here in case anyone wants to take a look.

On the surface it looks like the bit twiddling based solution should run faster because it does not make all those method calls, the other thing that I suspected was causing problems was the number of recursive function calls that were being made, so I put in some code to check the number of recursive function calls that were being made and to my surprise I found that CrazyBob’s solution was making 8877691 recursive calls as compared to my solution which was making almost 10 times that number. Also the actual soultion count is 8877690 which meant that the number of calls in CrazyBob’s solution was near optimal. So it was clear that it was the number of calls that were costing me the half second. Btw CrazyBob’s C# version still ran in 700ms on average on my laptop, which was still 500ms faster than my C# version.

I then started to think about alternate ways to attack the issue, one track I went down was to consider all the digits as a complete graph and then coming up with a way to enumerate all paths in the graph, traversing a n edge in the graph would remove other edges from the graph and make them not available. This reminded me on Knuth’s Dancing Links Algorithm and I read up on that a bit, this paper from Knuth on the subject was an excellent read. It looked to me that CrazyBob had used an approach similar to the DLX algorithm, but after reading the entire paper from Knuth it still didn’t strike me as to why using a DLX approach would provide such excellent performance as compared to my version.

So I went back a bit to comparing both solutions and I think the two key observations that I saw that

1. CrazyBob’s solution went down the search tree to one level above the last and then just generated all the solution from there instead of recursing down to the last level, so for e.g. supposing it was generating 5 digit numbers and it had already generated 4321, then at that level it didn’t make additional recursive calls to add the final digit, it was able to add the last digit at the same level pruning the search tree quite a bit. In contrast my solution was basically doing a method call for every digit of every number in the solution set.
2. The above optimization was made possible by using the length of the final solution as the key, so first all 1 digit solutions were generated, followed by two digit ones and so on.

Cool, so now I ported my bit twiddling version to generate based on the length of the numbers and the optimization to prune the search tree one level above the last came naturally. I ran my solution and guess what, it was still 200 ms slower than CrazyBob Aaaarghhhh!!!!!

for (int len = 1; len <= 10; ++len) {
····Generate(len, 0, 0xFFF >> 2, 0);
}

private static void Generate(int maxLen, int currentLen, int availableDigits, long currentValue) {
····bool last = (currentLen == maxLen - 1);
····for (int digit = (currentValue == 0) ? 1 : 0; digit <= 9; ++digit) {
········if ((availableDigits & (1 << digit)) != (1 << digit))
············continue;

········if (last) {
············++_total;
············//Console.Write("{0}, ", (currentValue * 10) + i);
········}
········else {
············Generate(maxLen, currentLen + 1, availableDigits & ~(1 << digit), (currentValue * 10) + digit);
········}
····}
}

But I knew I was getting close, at this point I knew what was killing me basically to determine which bits were set I was iterating from 0 to 9 and then testing if that bit was set in the number or not, this test was killing me because most of the times the bit was not set and I was doing a huge huge number of unnecessary tests. So I needed a way to iterate through only the set bits. The first solution I tried used a hashtable but that caused a even bigger degradation in performance. Finally for a lack of a better way to express this in C# I had to waste 4KB of memory and use an array to allow me to iterate through the indexes of the set bits in a number.

The final solution ran in 350ms on average, almost a 50% improvement over CrazyBob’s solution, woot!!!!! A further optimzation to move the if statement from inside the loop to outside which makes the code more readable but incredibly smelly because of the near duplicate code in both the if and else blocks shaved off another 50ms. Here’s the final version without the optimzation for moving the if statement outside which makes the code a bit shorter.

class Beust5
{
····private static int _total = 0;
····private static int[] _pre = null;
····public static void Run() {
········_total = 0;
········_pre = new int[(1 << 10) + 1];
········for (int i = 0; i <= 10; ++i) {
············_pre[1 << i] = i;
········}

········for (int len = 1; len <= 10; ++len) {
············Generate2(len, 0, 0xFFF >> 2, 0);
········}

········Console.WriteLine("nTotal: {0}", _total);
····}

····private static void Generate2(int maxLen, int currentLen, int availableDigits, long currentValue) {
········bool last = (currentLen == maxLen - 1);
········int x = availableDigits;
········while (x != 0) {
············//digit will contain the lowest set bit
············int digit = _pre[x ^ (x & (x - 1))];
············x &= (x - 1);

············//Avoid starting with zero
············if (digit == 0 && currentValue == 0)
················continue;

············if (last) {
················++_total;
················//Console.Write("{0}, ", (currentValue * 10) + i);
············}
············else {
················Generate2(maxLen, currentLen + 1, availableDigits & ~(1 << digit), (currentValue * 10) + digit);
············}
········}
····}
}