Nathan Brixius : Project

Writing high performance code

Nathan Brixius — Fri, 11 Dec 2009 04:29:00 GMT

During Scott Hanselman's podcast we briefly discussed managed code performance. Here are a few of my thoughts about writing high performance code. In the spirit of a cheesy business book (or motivational speaker), I will give away my main points in the form of controversial-sounding statements before proceeding to flog them to death:

Don't trust anyone.
Managed is better.

Some background: before I came to Microsoft I built solvers for both discrete and continuous optimization problems, primarily in C/C++, with a bit of Fortran thrown in. Back in 2002 when I was on the Project Server team we were faced with the decision of whether to rebuild our scheduling engine in C++ or C#. For the past year or so I have worked on the Solver Foundation team, which is pure C#. We build solvers that solve a range of large-scale optimization problems, and they are “industrial grade”: tens or hundreds of thousands of constraints are not uncommon.

Don't trust anyone. Rico Mariani says the first rule of performance is to measure. Listen to Rico. There are many reasons for this. The first is that nobody has ever written code that is doing exactly what you are trying to do. Otherwise (being a smart programmer) you should just call their code or (being a smart business person) you should just buy their code, try to do it better, or do something different entirely (perhaps mixed martial arts). So you should seek to understand how the code behaves, otherwise you will never find out - until it is too late.

The second is that you know your scenarios and priorities better than others do. You should already have an idea of how fast the code is supposed to be. Now sometimes the requirement truly is "make it as fast as possible". For numerical libraries this is often the case because many problems can be made to be arbitrarily complicated. For example, if you are modeling fluid dynamics you could use tighter meshes and get more accurate results. In most other cases (perhaps in a user interface) you have a hard number you need to hit. Of course, there are some simple guidelines that may apply in most situations. If you never go to the database, your server app will be fast. If you never allocate memory, your numeric code will fly. True or false? Well…measure.

The third is that even if someone else has measured code that seems to be similar to yours, their results may be misleading. For example, you depend on different collection classes, or you are running on a different processor. Or your input data is different in some subtle way. To take a very simple example, suppose you want to sort lists of 1 million integers, and somebody says, "hey, I measured different sorting algorithms on arrays of 1 million integers and quicksort is best." And they hand over the code and all of their results. Well, what do those arrays look like? Because if the data is mostly sorted then something like insertion sort may work better.

If you follow this advice you may end up with more questions: doesn't this take a lot of time and effort? How do I know when to stop measuring, or stop optimizing my code? If you start profiling at the very start of development, and build some simple skills, it's not too bad (and you learn a lot). If, for example, you are considering whether to use managed or unmanaged code for a project, prototype a couple of key sections in C++ and C# and measure. I did this on the Project Server team and that was the best way to settle the argument. These things often get way too philosophical – just try it and see. I did standard critical path scheduling in both C# and C++ and found that the C# version was only 10-15% slower. We went with C# and in the course of development we were able to find algorithmic improvements that resulted in a faster implementation that the original C++ codebase. Get good at writing simple programs that answer one specific performance question. For example: should I use a list or an array? How should I read this data set? Be a scientist and seek to answer specific questions by controlling the conditions and varying only one thing at a time. And pick the right thing based on your knowledge of the customer scenario.

Managed or unmanaged? My blunt opinion is: unless your computation is dominated by BLAS-style computations you are better off using C# because of productivity, stability, and maintainability concerns.

Here are a couple of “pros” for C#:

There are clear performance differences, but in many cases when you look at the overall system performance they can be washed away due to other factors: I/O, a webservice call, DB access, etc.
Many programmers (myself included) are much more productive writing C# code. This gives me more time to investigate possible algorithmic improvements, write good unit tests, etc. There are opportunity costs!
I think it is easier to make use of multiple cores. For example, the parallel extensions available for .Net 3.5 (and built into 4.0) are very easy to use.

There are also some clear downsides:

It is easy to get lazy, or to unintentionally use constructs that are not efficient. People start using List<> and Dictionary<> when a good ol’ array will do. It’s also easy to miss unnecessary memory allocations, because everything is garbage collected. So you need to be vigilant about profiling the code.
There is a lot of unnecessary array bounds checking that slows things down. In particular, with LAPACK-style routines with tight, nested loops.
As far as I know, the managed code compilers do not make use of SSE2 instructions.

Others have different opinions and I’m not saying they’re wrong - so long as they have measured. Otherwise they are bullshitting you.

Resource constrained scheduling; OML tutorials

Nathan Brixius — Wed, 01 Apr 2009 05:43:00 GMT

Two weeks back I posted two articles showing how easy it is to model critical path scheduling using Microsoft Solver Foundation. I received a few emails asking about various extensions; I will be covering those in upcoming posts. Julian just wrote a great blog post that covers the most commonly requested extension - resource constrained scheduling. If you are getting started with Solver Foundation and want to see an interesting, instructive example, I encourage you to check out his post. Two things that I really like about his OML:

He separates the data from the model description using Parameters.
He relies on the Foreach construct to define his constraints. It results in a very clean model definition.

Julian mentions it in his post, but I also want to call out another great resource for learning OML. Erwin Kalvalagen has written an OML tutorial which includes several interesting examples. It's a great complement to the Excel Programming Primer that is part of the Solver Foundation documentation.

Project Scheduling and Solver Foundation: links and constraints

Nathan Brixius — Fri, 06 Mar 2009 19:04:00 GMT

Yesterday I introduced a simple OML model for computing project schedules. The model has the following sections:

Parameters: input data that comes from Excel.
Decisions: the values that I want to solve for.
Constraints: the relationships that decisions and parameters need to satisfy.
Goals: the objective - what I want to optimize.

The exciting cliffhanger from my previous post was to model precedence links. Let's think about how I could specify the links in Excel. One way to do it is to have a table that simply lists the "predecessor" and "successor" tasks. For example:

Pred	Succ
0	1
1	2

The first row says that task 0 is the predecessor of task 1, i.e. task 1 should start after task 0 finishes. If we want to bind this data to our model, we should introduce a Set and a Parameter, just like we did for Tasks:

  Parameters[Sets, Links],
  Parameters[Integers, Pred[Links], Succ[Links]],

The domain for Pred and Succ is Integers because the table stores indexes for the tasks. Now I need to change the model to enforce the links. That's a constraint, which is expressed straightforwardly using a Foreach:

    Foreach[{l, Links}, Start[Succ[l]] >=Finish[Pred[l]] ]

If I setup the data binding for Links and re-solve, then I will see that the links are honored. If you compare to Project's schedule, you may spot a problem: some of the tasks (for example t3) are scheduled later than they are in Project. This is totally valid according to our model - t3 has "slack" and can move around without affecting the project schedule. Think about how you could fix up the model to match Project, so that all tasks are scheduled "as soon as possible".

On to the "extra credit" problem: how to model "start no earlier than" (SNET) constraints. This is actually not too hard if we just consider the SNET date to be another parameter just like Duration. The constraint is straightforward:

  Parameters[Reals, SNET[Tasks]],
  Constraints[ Foreach[{t, Tasks}, Start[t] >= SNET[t] ]]

In my Excel spreadsheet, I added a SNET column with the date for the constraint for each task. If a task does not have a SNET constraint, I just fill in a dummy date (e.g. 1/1/2009). But I need a number, not a date, so in the adjacent column I add the formula "=C2-TODAY()" to give me the number of days since the project start date. That's what I want to bind to.

For reference, here is the data in my spreadsheet:

And here are the data bindings I created using the "Binding" button in the Solver Foundation ribbon:

If you've been working with the spreadsheet, you may have been annoyed by a couple of things:

If I add new tasks, I need to change the data binding to include the new cells.
The conversion between dates and numbers is kind of bothersome.
This is getting complicated. For example, Project has eight different constraint types. If I wanted to model them all the same way I modeled SNET, I would need to add a whole bunch of spreadsheet columns.

Maybe it's time to turn this OML model into a C# program that directly calls Solver Foundation Services to model and solve project schedules. Next time we will do just that.

Project Scheduling using Solver Foundation

Nathan Brixius — Thu, 05 Mar 2009 21:19:00 GMT

I'd like to work through a few examples of how to model real problems using Solver Foundation. If you download the Solver Foundation Express Edition, you can follow along: start Excel, click the Solver Foundation tab, then click on the Model button to get a blank modeling pane.

I spent my first five years at Microsoft on the Project team, writing the project scheduling engine for Project Server. Project is a great team and an awesome product, and I still have a soft spot for project scheduling. My intent is not to reinvent Project - just to make a connection with a familiar problem so I can show off the Solver Foundation platform while introducing some key concepts. For those who don't know Project, the goal is to come up with a schedule for a list of tasks in a project. Here are a few of the basics:

Tasks have a start, finish, and duration.
No task starts before a given project start date.
The finish date is computed as start + duration.
A pair of tasks can be linked by precedence relationships. When there is a link from a task A to a task B, the B's start must occur on or after A's finish date.
The project finish date is defined as the latest finish date of any task in the project.

Given these requirements, we would like to compute the start and finish dates for all of the tasks in the project, and we want to find a schedule ends as soon as possible. Let's use the Solver Foundation to create a model in OML (Solver Foundation's declarative language) and compute some schedules. I always find it helpful to work out an example before I try and model a problem. Here's a simple schedule in Project with five tasks, and two links that connect t0, t1, t2. To compute the schedule by hand I could use a simple critical path scheduling algorithm.

Right away you can spot a few issues:

I haven't taken calendars into account - normally I don't want to schedule work on Saturdays and Sundays.
I haven't taken resources into account - in real life, people (or machines, or rooms) are assigned to work on tasks, and their availability may affect my schedule.
There are lots of cool Project features that I haven't taken into account - e.g. task constraints, summary tasks, etc.
I haven't taken uncertainty into account - in real life, durations aren't known precisely.

I will revisit some of these points in future posts - these are all things that I can address with Solver Foundation. For now, I am going to stick with a simple version of the problem. I'd rather get a correct model on a simplified version of the problem than an incorrect model on a more complex one! In this sense, modeling is no different from writing an essay or designing software.

There are a few questions to ask yourself when building an OML model:

What are the key objects or entities that I will be working with? (tasks, links)
What do I want the solver to compute? (start and finish dates for tasks)
What do I know? (the durations on the tasks)
What are my restrictions? (links enforce an ordering on tasks, start + duration = finish)
What do I want to optimize? (the finish date on the project)

If you have good answers to these questions, and start simple, you can usually come up with an OML model that describes the problem. Let's start by modeling the start and finish dates of the tasks, since that is ultimately what we want to find out. Each task has a start and a finish - these are dates. Solver Foundation does not directly support date values, so let's say that start and finish are real numbers, representing the number of days since the project start date. To express the idea that each start and finish is associated with a task, we define a "set" Parameter. The start and finish dates are the values that we want the solver to figure out, so these are Decisions:

Model[
 Parameters[Sets, Tasks],  
 
 Decisions[
     Reals[0, Infinity], Start[Tasks], Finish[Tasks]
  ],

Notice the syntax for Decisions: the first argument indicates the possible values (domain) for the decisions. We could have used Integers[0, Infinity] for the first argument, but then we would not be able to model fractional days. Loosely speaking, the start and finish dates are the "output". What's input? The durations. Let's suppose that the durations are entered into our spreadsheet like this:

Task	Dur
t0	1
t1	2
t2	3
t3	2
t4	4

We will define Duration as a Parameter so that we can use data binding to determine the values. Just like Start and Finish, Duration is indexed by Task.

Parameters[Reals, Duration[Tasks]],

After entering the duration data into Excel I can use the Binding button to add a binding from the range B2:B6 to Duration. When I solve the model, Solver Foundation will use whatever values are entered in the spreadsheet. But let's not get ahead of ourselves...next let's express the relation between Start, Finish, and Duration. Relationships that need to be enforced are described using Constraints. OML provides a bunch of operators and expressions for describing constraints. In this case, we have one constraint per task. This is easy to express using Foreach:

 Constraints[
    Foreach[{t, Tasks}, Start[t] + Duration[t] == Finish[t] ]
 ]

We almost have a working model - the last thing we need to express is our Goal: that we want the project to finish as soon as possible. So let's introduce ProjectFinish as another decision:

 Decisions[
     Reals[0, Infinity], Start[Tasks], Finish[Tasks], ProjectFinish
  ]

The ProjectFinish is the maximum finish date of any task in the model. In other words, it is at least as big as the Finish date of each task, so we add this constraint.

  Foreach[{t, Tasks}, ProjectFinish >= Finish[t] ]

Now we can express our goal: minimize the project finish:

  Goals[ Minimize[finish -> ProjectFinish ] ]

The "->" syntax simply gives a label to our goal, it's optional. Here's the complete model:

Model[
  Parameters[Sets, Tasks],  
  Parameters[Reals, Duration[Tasks]],

  Decisions[
     Reals[0, Infinity], Start[Tasks], Finish[Tasks], ProjectFinish
  ],

  Constraints[
    Foreach[{t, Tasks}, Start[t] + Duration[t] == Finish[t] ],
    Foreach[{t, Tasks}, ProjectFinish >= Finish[t] ],
  ],
 
  Goals[ Minimize[ finish -> ProjectFinish ]  ]
]

If you have entered this into the modeling pane, and used the Binding button to define the data binding between the spreadsheet data and Duration, you can hit Solve and observe the Start and Finish dates. You will see something like this:

If you want to turn the starts and finishes into dates, you can enter a formula like "=now() + C5" in the adjacent column. Actually I put this formula in a column next to my duration values, so I can see the durations, starts, and finishes all in one place.

You should be thoroughly unimpressed by this model (as I am ;)), because it doesn't do all that much. All I'm doing is letting Solver Foundation compute finish = start + duration, which I could have done very easily in Excel. I need to model "links": a link causes the start date of the successor task to be later than the finish of the predecessor task. If you've made it this far, you have all the building blocks you need to model this in OML. Feel free to post your solution here, or just wait until tomorrow for my solution.

Extra credit: if you use Project, you know that you can define "constraints" on tasks. For example, I can double click on a task and say that a task must "Start No Earlier Than March 30, 2009". These constraints need to be honored, in addition to links. How can I model SNET constraints using OML?

Testing Columns in a Project DataSet

Nathan Brixius — Mon, 08 Jan 2007 21:44:00 GMT

Larry Duff of the Project team wrote a very nice article describing how to test column values when making calls to the Project Server PSI: http://blogs.msdn.com/lduff/archive/2006/12/06/testing-columns-in-a-dataset.aspx

DavidK remarked in a comment that the PSI offers methods to handle the case where a column in the result set does not have a value. If you use these, you don't need to do a try-catch:

private string GetWSSSite(Guid projectGuid)
{
   ProjectWS.ProjectDataSet pds =
      ProjWebSvc.ReadProject(projectGuid,ProjectWS.DataStoreEnum.PublishedStore);

   return (pds == null)
      || (pds.Project.Rows.Count == 0)
      || pds.Project[0].IsWPROJ_STS_SUBWEB_NAMENull() ?
      String.Empty : pds.Project[0].WPROJ_STS_SUBWEB_NAME;
}

I don't believe that the subweb name is a mandatory field, so it's appropriate to return String.Empty as a result rather than throwing an exception. (But if the ReadProject call returns no results you may want to think about throwing an exception if you expect that projectGuid refers to a valid project.) Another note: the IsXXXNull() method exists for all columns in all DataRow classes in the PSI. If you write code against the PSI you should get in the habit of taking advantage of these methods.