Way2Solve

Source Control for Agile Development

2011-09-04T06:19:00.001-07:00

This paper describes an example of how to handle version control in an agile environment with multiple teams. I'm going to assume that you are familiar with the basic elements of Scrum and XP and task boards. I didn't invent this scheme - it is based on the "mainline model" or "stable trunk pattern". See the references section for more info.

I wrote this paper because I keep bumping into teams that really need something like this. Most teams seem to like the model quite a lot once they understand it. This is also the scheme that we migrated to at the company described in "Scrum and XP from the Trenches". It really helped us develop and release software in a more agile manner. By describing the model in an easy-to-read fashion maybe I won't have to explain it as often over a whiteboard :o)

Note that this is only one pattern among many, not a silver bullet. If you do choose to use this pattern you will probably need to adapt it to match your particular context.

Goals

In an agile environment with multiple teams the version control model needs to achieve the following goals:

Fail fast
- Code conflicts and integration problems should be discovered as soon as possible.
- Better to fix small problems often than to fix large problems seldom.
Always releasable
- Even after a really bad sprint there should be at least something that is releasable.
Simple
- All team members will be using this scheme every day, so the rules and routines must be clear and simple.

Single page summary (for wall mounting)

If this picture is confusing to you, don’t worry, just read the paper.
If this picture is obvious to you, don’t bother reading the paper.

This summary is also available as a downloadable pdf

The version control pattern

Branch owner & policy

Here's a simple rule.

Rule: Each branch (even the trunk) has an owner and a policy.

Otherwise we get a mess. The policy describes rules for what kind of stuff is allowed to be checked into this branch. The owner is the person responsible for defining and following up the policy.

The "done" concept

When is a user story "done"? More specifically, when your team moves one particular user story into the "done" column on their taskboard, what does that actually mean?

I'll assume the following.

Assumption: Definition of Done = "releasable".

So when a team member says that a story is Done and moves the story card into the Done column, a customer could run into the room at that moment and say "Great! Let's go live now!", and nobody in the team will say "no, but wait".

You can use whatever definition of Done you like. But remember - if the definition is anything less than "releasable" you need to consider: what is not included in Done? And who will do that other stuff? When? And what happens if something goes wrong after Done?

The Done branch

When a story is Done, it needs a home. With my definition of Done ("releasable") that means there must be some branch in the system that you could release from in order to get that story into production. That's the Done branch.

Any branch could be the Done branch. I'm going to use the trunk as the Done branch (a good starting point). Sometimes this is called the "mainline".

Assumption: Trunk is the Done branch.

Trunk policy:

Can release at any time
Want to release ASAP

"Can release at any time" means just that. At any moment, the product owner can decide that we should make a new production release directly from the tip of the trunk.

Here's an example.

The blue line represents the trunk. Each green ball represents one checkin. So 5 things were checked in during this sprint. We could release from the trunk at any time, although we will typically do it at the end of each sprint. If half the team gets sick near the end of the sprint and they don't have time to finish story #5, we could still make a release. And, of course, we could choose not to make a release and instead wait another sprint to get story #5 in.

"Want to release ASAP" means that we shouldn't check in a story unless we want it to go live (or at least wouldn't mind if it goes live). If story #3 above is something that I don't want to release, I've essentially killed the branch. Since the branch is no longer releasable, I've violated the branch policy.

Rule: Don't combine different release cycles on a single branch

When do we create additional branches?

As seldom as possible. Here's a good rule of thumb.

Recommendation: Only create a new branch when you have something you want to check in, and there is no existing branch that you can use without violating its branch policy.

Work branches

OK, so let's say we have our nice and clean trunk, releasable at any moment.

Wait a sec. Releasable means integration tested. And that means we need to run integration tests. So we need to run integration testsbefore checking in to the trunk.

So where do I check in code that I believe is done, but need to verify before checking in to the trunk? Of course, I could test it locally on my machine, and then check it directly into trunk. But that's a bit scary, I'm sure you've all run into the "hey but it works on my machine" issue.

Another issue is "OK, I'm finished coding for today, I'm going home now. Where do I check in my code? It's not tested yet, so I can't check in to the trunk. I want to check it in somewhere so that other team members can continue working on it" (agile team = collective code ownership right?)

There we go. We have stuff we'd like to check in, and there's no place we can check in without violating a branch policy. That's a valid reason to create a new branch.

Let's call this a work branch, shared by all members of the team. Some people call it a development branch.

Team A work branch policy:

Code compiles & builds, all unit tests pass.

Great, so now we have two branches! One stable branch (the trunk) and one slightly less stable branch (the team branch). The team branch is red to highlight that it is less stable, i.e. the stuff on that branch passes the unit tests but it might not be integration tested and might not be stable enough for release. OK, so the now team has a place to check in work in progress!

Hmmmm. What about synchronizing the branches then? Read on.

Publishing from work to trunk

At some point (hopefully) a story will get Done. More specifically, at some point the work branch will get to a point where it is releasable. At that point we can (and should) publish to the trunk, i.e. take all new code on the work branch and copy over to the trunk. After that the trunk and the work branch are identical.

We can call this "publishing" since we have been doing some work and are now ready to "publish" it back to the trunk for release. Just a helpful metaphor.

Here's an example. Let's say we've implemented two stories: Register and Deposit. They are Done, i.e. unit tested, integration tested, and releasable. We have started working on Withdraw, but it is not Done yet. The taskboard would look something like this:

Each yellow stickynote on the board represents a task, i.e. one piece of work needed to complete the story. For example edit class X, update the build script, etc. Each task typically represents about 1 man-day of work, each story typically represents about 3 - 8 man-days of work.

The branch history would look something like this:

So first our team implements Register. Checkin to the work branch, run the integration tests, fix some problems, checkin again, run the tests again, works! Register is Done! Publish it to the trunk.

Next implement Deposit. Only one checkin was needed. Integration tests pass, so we release to trunk again.

Now the team is in the middle of implementing Withdraw. They have done two checkins so far, but aren't done.

Note that "release to trunk" doesn't mean that we are copying the code for one specific story to trunk. It means we are copying everything from work to trunk, i.e. doing a complete synchronization.

So two interesting questions arise:

What if our team implements multiple stories in parallell?
What if other teams are publishing to the trunk as well?

Let's do one at a time.

What if our team implements multiple stories in parallell?

If the team implements one story at a time, publishing to trunk is trivial. As soon as a story is implemented and tested on the work branch we copy everything from work to trunk. Done.

But wait. What if we are doing multiple stories simultaneously within the team? What if Register is done and Deposit is in progress?

If we synchronize to trunk at this point, we will be including the partially complete Deposit story, which isn't releasable! Violation of trunk policy!.

Of course, we could wait for Deposit to complete.

(waiting...)

OK Deposit is complete now! Great! Wait a sec... now somebody has started working on Withdraw! Ack! Same problem!

If one of the Deposit tests fail it will be hard to know if that is due to the Deposit code or the partially complete Withdraw code that is checked in to the same branch.

Waiting doesn't help. We are rolling a snowball, saving up for a big bang release at some hypothetical point in the future when all stories are complete (if that ever happens).

This is an extremely common problem. So what do we do?

Here are some strategies:

Don't do so much parallell development. Try to focus the team on one story at a time.
If someone is going to start work on Deposit before Register is complete, wait to check in the Deposit code until Register is complete. Or maybe even check in Deposit on a separate temporary branch if you enjoy juggling branches.
If someone is going to start work on Deposit before Register is complete, start with the safe and invisible bits, code changes that aren't going to affect the releasability of the branch. For example if Deposit requires some new code and some modification of existing code, implement the new code now (new methods, new classes, new tests, etc) but not the modifications. If Deposit needs new GUI elements then make them invisible for now. Once Register is complete and released to the trunk we can start implementing the rest of Deposit.

Here's a convenient rule set:

Anyone working on the top priority story is King.
Everyone else on the team is a Servant.
You want to be King. Try to find ways to help out with the top priority story.
Whenever a King needs help, Servants immediately offer their services.
A Servant may not disrupt a King.
A Servant may never check in unreleasable code on the work branch. A King may check in whatever he pleases (as long as he doesn't violate a branch policy of course).
As soon as the top priority story is Done, anyone working on the next story is now King.

You might even get a few crowns for the team :o)

On the whole, many teams seem to over-rate the benefits of implementing many stories concurrently. It gives a nice feeling of speed but can be an illusion since it pushes the risky and time consuming bits to the end - merging and integrating and testing.

That's why Scrum teams are supposed to be small (< 9 people) - so that they can collaborate closely and focus their efforts. If everyone does their own story concurrently there probably isn't much collaboration going on. Sure you can have people looking ahead, preparing the next story and doing some of the implementation. But at any given moment the bulk of the team's efforts should be focused on the top priority story.

Multiple teams are a different story. Multiple teams are created when you specifically want to implement multiple stories in parallell. We'll look at that in a moment. First I want to talk a bit about regression testing and diverging code within the team.

Done includes regression testing!

When a story is Done we move it to the Done column and copy from work to trunk. The trunk must always be releasable. This has an important implication.

Rule: Whoever touches the trunk is responsible for ensuring that the whole trunk stays releasable - including all previous functionality!

This rule means, in effect, that testing story A also includes running all relevant regression tests for previously implemented stories. It is not enough that story A works if that code has broken previous stories.

Wait a sec. Isn't that unreasonable? Running all regression tests every time a story is complete?
Well, first of all I didn't say all regressions tests. I said all relevant regression tests. Remember that we had a nice clean releasable trunk as a basis, and now we are just adding one story! That is a fairly small incremental change. If our regression tests are automated we could run them all. But if there are manual regression tests we will have to be selective.
It all boils down to a risk vs cost tradeoff. For each manual regression test we should evaluate the cost of the test (i.e. how much work it is to do the test) vs the likelihood that any important defects will be discovered. And of course weigh in the cost of automating that test :o)

Diverging code (merging conflicts)

What if I'm happily writing code that calls the Widget class. What I don't know is that my team member Jim removed the Widget class one hour ago, in conjunction with a refactoring. So now we havediverging code. I want to discover this as soon as possible, before wasting time writing even more code that calls the Widget class.

Rule: Synchronize your code with the work branch continuously (= as often as possible)

Synchronize in this case means both directions. Merge down the latest from the work branch, and check in your code. The first part can be called "catching up" (= I want to find out what other people have checked in). The second part can be called "publishing" (= I want my changes to be made available to the rest of the team).

Once per hour or so is a good habit, basically whenever you move from one task to another and aren't in the middle of a flow. This is not just about "I want to find out ASAP when someone else writes code that conflicts with mine", it's also about "I want the other guys to find ASAP if I write code that conflicts with theirs". Just remember to not break the policy of the work branch (unit tests pass and whatnot).

This rule may sound rather obvious but bear with me. I want to make this crystal clear since we will be reusing this mindset further down when dealing with multiple teams.

Multiple teams - what if other teams are publishing to the trunk as well?

Let's say we have team A and team B. They are cross functional feature teams working on a flight booking system. Team A is focusing on the booking process, team B is focusing on the backoffice stuff.

Let's say they are going to start a sprint now, with two user stories per team (usually there will be more stories than that in a sprint).

Each team has their own work branch, since they each need somewhere to test their code before publishing to the trunk.

Now we have an interesting problem. Let's say I'm in team A and we have our work branch. Changes might be made in the trunk, without being made in my work branch first! Why? Well because there's another team out there, and they will publish to the trunk whenever they finish a story!

So at any given moment, there may be new code on the trunk that I don't know about. And that code might (god forbid) conflict with my code! Maybe someone in team B renamed the Widget class that I call from my code and... uh... wait a sec. Didn't we just talk about this?

Yep, that's right. It's the same problem. And same solution. But on a slightly different scale.

Rule: Merge from trunk to your work branch every day

Every day when I get to work, someone in my team is responsible for merging the latest version from trunk to our team work branch (= "catching up" with changes made to the trunk).

If my team (team A) discovers a code conflict we resolve it immediately - that's top priority! If we need help from team B (or whoever wrote the code that conflicts with ours) go fetch them and work together to sort it out. The important thing is that my team is responsible for getting the problem sorted out, and that we need to sort it out on our own work branch (not on the trunk).

Rule: Resolve conflicts on the branch that is least stable

Of course, merging from trunk is a waste of time if people don't publish to the trunk on a regular basis. Any divergence between team A and team B is invisible until someone publishes to the trunk. So here's the next rule:

Rule: Merge from your work branch to the trunk on a regular basis, for example whenever a story is done. Don't wait until the end of the sprint!

Note an interesting side effect here:

Side effect: Whoever checks in first wins!

If two teams are writing code that conflicts with each other, the last team to check in has to resolve the conflict. That's a nice side effect, since it encourages teams to check in early :o)

Here's an example of a whole sprint.

We are doing a 6 day sprint with two teams. Team A is planning to implement Book and Cancel. Team B is planning to implement Invoice and Blacklist. Let's look at what happened.

Day

</td> <td>

Team A perspective

</td> <td>

Team B perspective

</td> <td>

Trunk perspective

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Merge from trunk. Nothing new. Working on Book, checking in on our work branch.

</td> <td valign=top>

Merge from trunk. Nothing new. Working on Invoice, checking in on our work branch.

</td> <td valign=top>

Nothing happened today.

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Merged from trunk. Nothing new. Finished implementing Book. Integration-tested it. Done! Copy to trunk. Start working on Cancel.

</td> <td valign=top>

Same as yesterday.

</td> <td valign=top>

Book is now done!

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Merge from trunk. Nothing new. Still working on Cancel.

</td> <td valign=top>

Merge from trunk. Aha! There have been changes! Book has been added! Merge with our code in Team B branch, resolve any conflicts. Then keep working on Invoice.

</td> <td valign=top>

Nothing happened today.

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Same as yesterday.

</td> <td valign=top>

Merged from trunk. Nothing new. Finished Invoice. Integration test it (including Book!), copy to trunk. Start working on Blacklist.

</td> <td valign=top>

Invoice is now done!.

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Merge from trunk. Aha! There have been changes! Invoice code has been added! Merge with our code in Team A branch, resolve any conflicts. Then keep working on Cancel.

</td> <td valign=top>

Merged from trunk. Nothing new. Still working on Blacklist.

</td> <td valign=top>

Nothing happened today.

</td> </tr><tr><td valign=top>

</td> <td valign=top>

Merged from trunk. Nothing new. Finished Cancel, copy to trunk.

</td> <td valign=top>

Same as yesterday.

</td> <td valign=top>

Cancel is now done!

</td> </tr></tbody></table>

Sprint is done! All stories except Blacklist got done. But that's OK, we can still release! This is because we merged & integrated incrementally. If we wait until the end of the sprint to do this, any diverging code will be discovered at precisely the wrong moment - when we have the least time to fix it.

Release branches

Let's say we've finished sprint 1 and released version 1.0.0 of the system. Now, while we're in the middle of sprint 2, a serious defect is reported on the released version! Oh no! What do we do?

The simplest way is to simply fix it on the trunk and release a version 1.1.0. This means any new stories implemented so far during sprint 2 will be included in the new release. Theoretically this should be fine since the trunk is the Done branch and the definition of Done is "releasable". So whatever is on the trunk at any moment should be something that we want to release.

However there may be reasons not to want to release new stories right now. For example:

The fact that there is a serious defect essentially means that the trunk was broken at the time of the release. That in turn means that the sprint 2 stories are built on top of a broken foundation. We might want to fix the foundation itself without having to deal with the new stories as well.
Maybe the stakeholders don't want new features to be released in mid-sprint.
Maybe it takes a while to make a new release from the trunk, with new features and all, so we want a simple "hotfix" mechanism to get bugfixes out the door faster.

So how do we do it?

Create a release branch called release 1.0, based on the trunk at the time it was released.
Patch the defect on the release branch.
Merge from release branch to trunk immediately after releasing (so the patch is included in future releases).

Note that we don't have to create the release 1.0 branch when we do release 1.0.0. We can wait until the defect comes up. So we don't need to create a branch until there is something that actually needs to be done on that branch.

The big picture

OK, now I've gone through a fairly detailed example of how to put this pattern to use. Now let's back out a bit and look at the big picture.

In the mainline model, a branch is called a codeline (in fact, branch is considered to be an implementation of a codeline). Sometimes these are called streams.

A codeline's parent (i.e. the codeline that it originated from) is called its baseline. Mainline is the codeline that has no baseline.

So in our examples above we could conclude that:

The trunk is our mainline. It has no parent right?
All other codelines (release 1.0, team A work, team B work) have the trunk as baseline.

Here's a more complex example:

This picture tells us that:

The project X codeline was spawned from the mainline. The project is now complete, so the branch is closed.
Team A has an active work branch that was spawned from the mainline.
Team A also has an ongoing spike that was spawned from the work branch.
The release 2.3 branch is closed, since 2.3 is no longer in production and won't be maintained.

Each codeline has a relative firmness level with respect to its baseline, i.e. each codeline is either more firm or less firm (softer) than its baseline.

A firm codeline is stable, thoroughly tested, changes seldom, and is close to release.
A soft codeline is unstable, barely tested, changes often, and is far from release.

When drawing codelines, firm codelines branch upwards and soft codelines branch downwards. So looking at the picture above, we can conclude that:

Release 2.3 is firmer than mainline.
Team A work is softer than mainline.
Team A spike is softer than team A work.

The drawing format used above is useful for showing branch histories, but it can get a bit messy when there are lots of branches. Here's a cleaner format, showing only the currently existing codelines and where they spawned from.

I suggest drawing a picture of your branches in this format and putting up on the wall in the team room! Really helpful to look at when discussing integration issues.

An important rule is that all change flows along the lines! So no code should be merged directly from team A work to team B work, this will cause all kinds of confusion. Instead, changes in team A work should flow to the mainline and then down to team B work.

Everything above the mainline is a called a release codeline, which means a codeline that is firmer than the mainline.

Everything below the mainline is called a development codeline (or work), which means a codeline that is softer than the mainline.

Golden rule of collaboration:
- Always accept stabilizing changes
- Never impose destabilizing changes

So what does this mean in terms of the different types of codelines?

The picture above is just a colorful way of saying that:

Whenever a change is made on a release codeline, the change should immediately be merged down to its baseline, all the way down to the mainline.
- Example: A bug is fixed on R2.4.2. That should immediately be merged down to R2.4, and merged from there down to mainline.
A release codeline should never receive changes from its baseline.
- Example: New code is checked in to the mainline. This should not propagated up to R2.3 and R2.4.
Change flows continuously from baselines to development codelines.
- Example: Any change to the mainline should quickly flow on down to Team A and Team B, and from Team A on down to A spike.
Change flows from a development codeline to its baseline only at stable points.
- Example: Team B merges to mainline only when a story is complete and tested.

Whenever changes have been made to a codeline and its baseline, some kind of merge might be needed. Since code merging is a potentially error prone operation we want to do it on the softer of the two codelines. Once the merge is complete and verified, we can copy the merged code back to the firmer codeline.

Using our convention of drawing firm codelines higher up than soft codelines, we could derive a simple rule:

Rule: Merge down, copy up

Example: Team A notices that the mainline has been updated. They merge the changes down to their development branch and fix any conflicts. As soon as Team A development branch reaches a stable point they copy back up to the mainline. They do of course have to check that nothing else has been changed on the mainline in the meantime.

Variations to the model

The chapter "The version control pattern" describes an example of how to implement the mainline model.

The chapter "The big picture" describes the mainline model in more general terms.

In this chapter I'm going to mention some typical variations on how to implement this pattern.

Definition of Done doesn't have to be "releasable"

Just settle on any definition of Done, and make sure there is a branch to accomodate stories that are Done according to that definition. Be careful about leaving important things out of Done, though. If integration testing is not included in Done, when will you integration test?

Trunk doesn't have to be mainline

You need a mainline for this pattern to work. It doesn't necessarily have to be the trunk though (although the trunk would be a pretty natural choice in most cases).

Teams don't have to have their own branches

You can certainly have multiple teams sharing the same branch, or even working directly off the mainline. As long as you obey the policy of the branch.

Often teams like to have their own branches to avoid having partially complete stories causing interference between teams.

You don't need to create a new release branch each time

You might decide to use the same release branch instead of creating a new one after each sprint. That release branch could be called "currently in production" or something like that. Certainly a useful model if you never have more than one version in production at a time.

You don't need to release after each sprint

You can release after each story. Or after every third sprint. Choose your pace.

You don't have to run regression tests for each story

If regression testing or integration is truly a pain in your environment you may decide to save it to the end of the sprint, so you can batch up a few stories and test/integrate them together. That is your risk to take. If regression testing & integration is included in your definition of done, that simply means you risk getting 0 stories Done if you run into problems with this at the end of the sprint.

FAQ

Where does continuous integration (CI) fit into this?

Which branches should your CI server work on? This is really context dependent, but here is a good starting point.

Assuming that your policy for trunk is "Done & releasable", and your policy for each work branch is "unit tests pass":

For each work branch, CI server automatically and continuously checks that it builds and passes all unit tests.
- Issues a red alert if anything fails. Triggers the smoke machine.
For each work branch, CI server automatically and regularly (if not continuously) runs integration tests and regression tests.
- Displays a discrete warning if anything fails, since this is not part of the branch policy.
- This test is triggered manually whenever someone is considering to publish code from work to trunk, as a way to check that the story is Done.
For the trunk, the CI server automatically and continuously runs integration tests and regression tests.
- Issues a red alert if anything fails. Triggers the smoke machine, the siren, the USB rocket launcher, and calls in the national guard.

What's the best tool for this version control model?

Not sure. I know it works well with Perforce, I think it works with subversion, but I'm not too sure about CVS. Any input is welcome.

Remember one important thing though - the cost of switching tools is usually quite low compared to the cost of not being able to collaborate effectively! So figure out how you want to work, then find the right tool to support that.

What about checkins that aren't related to a user story?

Not all code changes have to be related to a user story, I just did that in all my examples for clarity. The same model applies no matter what type of code you are checking in (or documents for that matter).

Merging is a pain, so I want to do it as seldom as possible!

Congratudolences, you have mergophobia - the irrational fear of merging code! Merging is a pain because you do it as seldom as possible. The more often you merge, the less painful it is :o)

http://www.infoq.com/articles/agile-version-control

Ganesh Chaturthi Pooja Procedure

2011-09-03T09:04:00.001-07:00

How to do Ganesh Chaturthi Puja or tell us about Ganesh Chaturthi Pooja procedure? For any puja or vrata, the main objectives are neatness and dedication. If you have these two factors, then Vinayakas blessings will be surely with you.

Here it is the detail pooja procedure or steps involving in Ganesh puja on Vinayaka Chavithi festival.Perform ritual bath in the early morning and wear new or fresh clothes and be ready to do Ganapati puja.

Prepare Ganesh mandap or pandal with coconut or banana leaves, mango leaves and with flower garlands to install Ganesha idol. It is always recommended to buy or prepare eco-friendly or clay Ganesh idol. Adorn Ganesh idol with flower garlands and chandan (sandalwood) paste.
A Kalash or the pot filled with sanctified water and rice to be installed before invoking Lord Ganesha idol. The rice or water filled Kalash is also called Purna Kumbha. Kalasha Sthapana is performed before invoking Ganesh.
After Kalasha Sthapana, Ganesh idol is invoked chanting Avahan mantras or just chanting ‘Om Ganeshaya namaha or other simple Ganesh stotras.
Chant Ashtottara Shatanamavali or 108 names of Lord Ganesha. Siddhi Vinayaka Vratha katha is recited after chanting several simple Ganesh mantras.
Light the lamp and offer Aarti to Lord Ganesh reciting Aarti mantras.
Offer special recipes – modak, undralla payasam, kudumulu and the recipes made of several leaves and fruits. Offer coconut and light diya or deepam and incense sticks (agarbattis).
Generally during Ganesh puja on Ganesh Chavithi, devotees place books, pens and other education or office material at Ganesh idol or Ganpati pandal and take them after Ganesh idol os moved. Usually, at homes, Ganesh idol is moved on the day after Ganesh Chaturthi.
The above puja procedure is followed for several days till Ganesh nimajjan. But some people perform simple Ganesh puja on the rest of the days during Ganesh Navaratri celebrations.
Some devoted families or orthodox houses perform Ekavimsathi Patra Puja or Ganesh Puja with 21 types of leaves is performed during Ganesh Chaturthi festival. This Patra Puja signifies the eco-friendly nature in celebrating Hindu festivals especially Ganesh Chaturthi festival.

Heart disease in women

2011-08-14T22:50:00.001-07:00

Understand symptoms and risk factors

All women face the threat of heart disease. But becoming aware of symptoms and risks unique to women, as well as eating a heart-healthy diet and exercising, can help protect you.

Although heart disease is often thought of as a problem for men, more women than men die of heart disease each year. One challenge is that the heart disease symptoms in women can be different from symptoms in men. Fortunately, women can take steps to understand their unique symptoms of heart disease and to begin to reduce their risk of heart disease.

Heart attack symptoms for women

The most common heart attack symptom in women is some type of pain, pressure or discomfort in the chest. But it's not always severe or even the most prominent symptom, particularly in women. Women are more likely than men to have heart attack symptoms unrelated to chest pain, such as:

Neck, shoulder, upper back or abdominal discomfort
Shortness of breath
Nausea or vomiting
Sweating
Lightheadedness or dizziness
Unusual fatigue

These symptoms are more subtle than the obvious crushing chest pain often associated with heart attacks. This may be because women tend to have blockages not only in their main arteries, but also in the smaller arteries that supply blood to the heart — a condition called small vessel heart disease or microvascular disease.

Many women tend to show up in emergency rooms after much heart damage has already occurred because their symptoms are not those typically associated with a heart attack. If you experience these symptoms or think you're having a heart attack, call for emergency medical help immediately. Don't drive yourself to the emergency room unless you have no other options.

Heart disease risk factors for women

Although the traditional risk factors for coronary artery disease — such as high cholesterol, high blood pressure and obesity — affect women and men, other factors may play a bigger role in the development of heart disease in women. For example:

Metabolic syndrome — a combination of fat around your abdomen, high blood pressure, high blood sugar and high triglycerides — has a greater impact on women than on men.
Mental stress and depression affect women's hearts more than men's. Depression makes it difficult to maintain a healthy lifestyle and follow recommended treatment, so talk to your doctor if you're having symptoms of depression.
Smoking is a greater risk factor for heart disease in women than in men.
Low levels of estrogen after menopause pose a significant risk factor for developing cardiovascular disease in the smaller blood vessels (small vessel heart disease).

Is heart disease something only older women should worry about?

No. Women under the age of 65 who have a family history of heart disease should pay particularly close attention to the heart disease risk factors. Women of all ages should take heart disease seriously.

What can women do to reduce their risk of heart disease?

There are several lifestyle changes you can make to reduce your risk of heart disease:

Exercise 30 to 60 minutes a day on most days of the week.
Maintain a healthy weight.
Quit or don't start smoking.
Eat a diet that's low in saturated fat, cholesterol and salt.

You'll also need to take prescribed medications appropriately, such as blood pressure medications, blood thinners and aspirin. And you'll need to better manage other conditions that are risk factors for heart disease, such as high blood pressure, high cholesterol and diabetes. Some women at high risk of heart disease may also benefit from the use of supplements, such as omega-3 fatty acids.

Exercise to reduce the risk of heart disease in women

In general, you should do moderate exercise, such as walking at a brisk pace, for 30 to 60 minutes most days of the week. If you can't get all of your exercise completed in one session, it's fine to break up your physical activity into several 10- to 15-minute sessions. You'll still get the same heart-health benefits.

There are other small changes you can make to increase your physical activity throughout the day. You can take the stairs instead of the elevator, walk or ride your bicycle to do errands, or try some sit-ups or push-ups while watching television.

What's a healthy weight?

What's considered a healthy weight varies from person to person, but having a normal body mass index (BMI) is helpful. This calculation helps you see if you have a healthy or unhealthy percentage of body fat. A BMI of 25 or higher can be associated with an increased risk of heart disease. Losing just 10 to 15 pounds can help by lowering your blood pressure and reducing your risk of diabetes — both of which increase your risk of heart disease.

Is the treatment for heart disease in women different than in men?

In some women, plaques build up as an evenly spread layer along artery walls, which isn't treatable using procedures such as angioplasty and stenting designed to flatten the bulky, irregular plaques in some men's arteries. For some women, drug treatment — rather than angioplasty or stenting — may be a better option.

Certain heart medications, such as clot-busting drugs (thrombolytics) tend to be more effective in women than in men. Aspirin therapy benefits both men and women, but there's also a difference between men and women in the effects of aspirin therapy. In women, aspirin therapy seems to reduce the risk of stroke more than in men, while in men it reduces the risk of heart attack more than it reduces stroke.

Taking aspirin to prevent heart disease in women

Guidelines from the American Heart Association urge women to be more aggressive about cutting their heart disease and stroke risks. A daily aspirin can have a number of benefits for women, such as preventing heart attacks and strokes and reducing heart disease risk.

The guidelines recommend that women consider taking aspirin — which means have a discussion with your doctor about the risks and benefits of taking aspirin based on your own individual stroke and heart attack risk. Don't start taking aspirin for heart disease prevention on your own. The higher your risk of heart attack or stroke, the more that risk is reduced by taking aspirin, but the higher your risk is of bleeding.

Information on Newborn Child

2011-08-14T08:23:00.001-07:00

Changes in your Body...

Getting accustomed to new surroundings: After spending 9 months curled up in your womb; your little one will take time to get settled in her /his new surroundings. In this time the baby will love being cuddled and held close.
There are a few things that you should know to help you understand your baby better.

Limbs Look Short

Breast feeding is extremely important for both you and your baby. Breast milk provides all the nutrition your baby needs and also provides your baby with antibodies that protect him/her from infections. This is very important for your baby as their immune systems are not fully developed.
1. Do you have nipples?
2. Problems with breast feeding?

The Excercises

The process of recovering from your pregnancy will take time. You must understand that you have been through an incredible experience over the past 9 months and you will take some time to return to how you were, before your pregnancy.
1. Changes in your body.
2. Exercises to help you.
3. Concerned about your weight?

Post Partum Depression (Post Delivery Depression)

If you are feeling a little bit low in spite of having your little bundle of joy in your arms don't be alarmed. You might take some time to bond with your baby. This is quite common. You have just been through so much. The whole process is so exhausting that only those who have gone through it can actually understand it. Don't burden yourself with unnecessary guilt if you feel a little low and be positive.

TCS, Infosys, MindTree, HCL and other Indian IT companies to suffer as angry America wants its jobs back

2011-08-12T22:35:00.001-07:00

BANGALORE: Some American corporations are retaining a small, but highly-prized slice of software jobs at home, mindful of the record unemployment levels and the anger among locals who see work being shipped overseas.

For Indian software providers such as TCS, Infosys and HCL, such a development - it is not expected to become a mainstream trend - could chip away a fraction of new jobs that could have been offshored to them. In an interview with Bloomberg on Monday, Charlene Begley, chief information technology officer of GE, said his company was rethinking the strategy of outsourcing more than half of its IT work.

Already, GE has announced plans to add 15,000 jobs in the US over three years, 1,100 of which will be at the Detroit IT centre. Walmart has also decided to drive the development and design of its ecommerce platform from a new centre in Brisbane, California.
WALMART PUTS OFF BANGALORE CENTRE
Walmart will not open its own captive technology centre in Bangalore, a person familiar with the retailer's decision said last week. In the latest job posting on its website, Walmart has advertised nearly 150 new technology jobs in Bentonville, Arkansas. "Some of this, let's say at least a quarter of these, could have easily been managed out of a captive centre Walmart was evaluating to open in India," the person said.
At least a dozen executives at US-based firms and local American authorities said more companies would shift highend technology jobs as they are under pressure from their local constituencies to create jobs. "Companies like GE are under social pressure to demonstrate they care by creating local jobs. They have been practising economic sense for years and reaped enough profits," said a senior executive at one of the top US tech firms. He requested anonymity because his company counts GE among its top customers.

In January, GE Chairman & CEO Jeffrey R Immelt was named the head of US President Barack Obama's panel on jobs and competitiveness, which also includes the leaders of America's biggest firms, including Xerox and Intel.

"There is pressure to create jobs in the marketplace, as well as demands on technology to create revenue impact in the front office. Both these trends actually play to create jobs in onsite locations - the former as a good corporate citizen, and the latter in recognition of the new levels and roles that IT has to play in these days of mobility, social networks and advanced analytics," said Vineet Nayar, CEO of HCL Technologies.

He declined comment on GE's outsourcing strategy but said customers are increasingly asking vendors to play a role. "For instance, if you were to look at what has been happening in HCL, the cosourcing deals we do with customers have already brought 9,000 employees who were with customers into HCL ranks," Nayar added.

Co-sourcing involves the transfer of a client's workforce to the payroll of the vendor, a switch which ensures job security to local workers who would then become part of multi-year outsourcing contracts. Experts say creation of more local jobs in the US is not likely to have any material impact on India's $60-billion outsourcing sector.
"The costs of switching out of outsourcing relationships are too high for most, but I think you can expect to see more companies finding ways to create jobs in the US," said Esteban Herrera, COO of US-based HfS Research, which advises customers on outsourcing.

"But it is likely GE will be sending less high-end work to India based on this strategy; meaning growth, and especially growth in complex processes and services, will likely decrease or stop altogether." While GE has been outsourcing to India for over three decades, Walmart started its offshoring pilot with Infosys only last year.
GE currently outsources nearly $1 billion of software development and backoffice projects to Indian companies such as TCS, Wipro, Genpact, Patni Computer and MindTree. TCS is GE's largest Indian IT vendor, accounting for about $200 million of business a year. Genpact, originally a GE back-office captive, currently gets almost 40%, or around $450 million, of its revenues from the company.

"As a percentage, the jobs moving back are very small. For example, if 500 out of 60,000 jobs move back it is a drop in the ocean. The kinds of jobs that are moving back are select, niche jobs such as design. Politics is a factor, but it is not the only factor why this is happening," said Phaneesh Murthy, CEO of iGate, which counts GE among its top customers.

With inputs by N Shivapriya
Courtesy: Economic Times

Income Tax department to review all realty deals to unearth black money

2011-04-18T20:13:00.001-07:00

The income tax department plans to review realty deals following allegations of rampant use of black money in many transactions. "We will take appropriate action wherever we find involvement of black money in such transactions," said Sudhir Chandra , chairman, Central Board of Direct Taxes .

Chandra said the department would begin scrutiny of property deals in the national capital region and follow it up in other metros.

The value of most real estate transactions in the national capital are suppressed to save on stamp duty, capital gains tax and wealth tax and are believed to have black money component as high as 65%, said another income tax official.

The black money component continues to remain high despite most states now fixing circle rates, or minimum rate at which a property can be registered, for various localities.

The income tax department receives data on all property registrations worth more than 30 lakh as a part of its special data capturing mechanism from property registrars.

In a separate proposal, the government is also considering making it mandatory for registrars to report all property transactions under the anti-money laundering law. Any property transaction used to launder illicitly earned money will, after an amendment in the Prevention of Money Laundering Act, attract harsher punishment.

The department is expected to rely heavily on technology and information on taxpayers it receives from various sources under 360 degree profiling.

Realty sector has been on the income tax department's radar for a while and tops the list of sectors most searched.

"The department has received many complaints of the involvement of black money in the sale and purchase of land and houses," the official said.

Recently, a well-known Mumbai developer admitted to undisclosed income of 200 crore. In a separate case, 100 crore was recovered from a Surat-based real estate company .
In 2009-10 and 2010-11, the I-T Department unearthed unaccounted income of over 30,000 crore in its search and seizure operations.

Chandra said while the number of searches had come down but the amount of undisclosed wealth had increased as the department was making effective use of technology. "Use of technology and data as part of 360 degree profiling system has improved the quality of searches," Chandra said.

Source: EconomicTimes

How to Prevent Heart Disease

2011-04-18T11:05:00.001-07:00

Heart disease is one of the leading causes of death in both men and women around the world. While many people fret about cancer or Alzheimer, hundreds of thousands of men and women around the world die of heart disease before they get to the age when Alzheimer becomes a problem. Living in today’s world, one cannot help but hear stories of high blood pressure, heart attacks and other such problemsrelated to the cardio-vascular system. However, these stories are so common that we no longer take them as seriously as we should and end up suffering from the diseases that we ignored.
Smoking is bad for you; everybody knows that. Actually, smoking is high on the list of lifestyle choice that you should avoid if you value your health and, ultimately, your life. Among other bad things, smoking is the leading cause for high blood pressure and its consequences: strokes, heart attacks, heart failure, damage to the eyes and kidney failure. If you think that smoking helps ease stress, then try and avoid things that stress you. We all have to make ends meet, but deliberately adding a health risk to your problems is not the answer.
Drinking is yet another way of getting yourself in heart troubles. And I don’t mean the romantic kind of heart troubles, although drinking has done this for some people. I mean the kind of heart troubles that get you a resting place six feet under ahead of the time. The excess consumption of alcohol raises blood pressure and brings the same unpleasant consequences described above. And we’re not talking liver damage yet. A glass of wine once in a while is not a bad idea. A couple of glasses of gin or whiskey each day are a really bad idea. Not recommended.
And the third thing that you can do for yourself in order to stay healthy and avoid a while bunch of trips to the hospital is to follow a healthy diet and to exercise a couple of days every week. A healthy diet does not mean that you have to give up all the foods that you love, but simply to eat in moderation and to replace fast food and snacks with fruit and vegetables. There are healthy alternatives to nearly everything. And exercising doesn’t necessarily mean pumping iron at the gym. Walking or thirty minutes of aerobic exercises every other day can make a huge difference later on.
It really doesn’t take that much to lead a healthy life and get rid of bad lifestyle choices, especially since you’re doing this for your own good. Think again before lighting another cigarette, drinking another glass of alcohol or reaching out for a bag of snacks. We are living in a culture that makes instant gratification very easy, but having to spend years worrying about your blood pressure later on is simply not worth it.
By: Antony Joseph M

Telugu festivals and Tamil festivals

2011-04-15T21:08:00.000-07:00

Telugu festivals and Tamil festivals for the years 1985 and 1987;

Vaikunta Ekadesi: 03-01-1985, Thursday; 10-01-1987, Saturday.
Bhogi: 13-01-1985, Sunday; 13-01-1987, Tuesday.
Pongal: 14-01-1985, Monday; 14-01-1987, Wednesday
Maattu Pongal: 15-01-1985, Tuesday; 15-01-1987, Thursday.
Thai Amavasai: 20-01-1985, Sunday; 29-01-1987, Thursday.
Vasanth Panjami: 26-01-1985, Saturday; 03-02-1087, Tuesday
Ratha Saptami: 28-01-1985, Monday; 05-02-1987, Thursday
Thai Poosam: 04-02-1985, Monday; 16-01-1987, Friday.
Maha Shiva Rathri: 17-02-1985, Sunday; 26-02-1987, Thursday.
Maasi Magam 06-03-1985, Wednesday; 13-03-1987, Friday.
Holi Festival: 06-03-1985, Wednesday; 14-03-1987, Saturday.
Kaaradayan Nonbu: 14-03-1985, Thursday; 14-03-1987, Saturday.
Telugu New Year: 22-03-1985, Friday; 30-03-1987, Monday.
Sri Rama Navami: 30-03-1985, Saturday; 07-04-1987, Tuesday.
Panguni Uthiram: 04-04-1985, Thursday; 12-04-1987, Sunday.
Tamil New Year: 13-04-1985, Saturday; 14-04-1987, Tuesday.
Akshaya Tritiya: 23-04-1985, Tuesday; 01-05-1987, Friday.
Agni Nakshatram Begins: 04-05-1985, Saturday; 04-05-1987, Monday.
Madurai Chithirai Festival / Chithra Pournami: 04-05-1985, Saturday; 13-05-1987, Wednesday.
Agni Nakshatram ends: 28-05-1985, Tuesday; 28-05-1987, Thursday.
Vaikasi Visakam: 01-06-1985, Saturday; 09-06-1987, Tuesday.
Aadi Amavasai: 17-07-1985, Wednesday; 25-07-1987, Saturday.
Aadi Pooram: 21-07-1985, Sunday; 29-07-1987, Wednesday.
Garuda Panchami: 20-08-1985, Tuesday; 30-07-1987, Thursday.
Aadi Perukku: 02-08-1985, Friday; 03-08-1987, Monday.
Onam Festival: 28-08-1985, Wednesday; 05-09-1987, Saturday.
Varalakshmi Vratham: 30-08-1985, Friday; 07-08-1987, Friday.
Yajur Upakarma: 30-08-1985, Friday; 09-08-1987, Sunday.
Gayathri Japam: 31-08-1985, Saturday; 10-08-1987, Monday.
Maha Sankata Hara Chaturti: 02-09-1985, Monday; 12-08-1987, Wednesday.
Krishna Janmastami: 07-09-1985, Saturday; 16-08-1987, Sunday.
Ganesh Chaturti / Vinayaka Chaturti: 17-09-1985, Tuesday; 28-08-1987, Friday.
Mahalaya Amavasai: 13-10-1985, Sunday; 22-09-1987, Tuesday.
Navarathri Begins: 15-10-1985, Tuesday; 24-09-1987, Thursday.
Saraswati Pooja / Ayutha Pooja: 22-10-1985, Tuesday; 01-10-1987, Thursday.
Vijaya Dasami: 23-10-1985, Wednesday; 02-10-1987, Friday.
Diwali / Deepavali: 11-11-1985, Monday; 21-10-1987, Wednesday.
Skanda Shashti: 17-11-1985, Sunday; 28- 10-1987, Wednesday.
Thiruvannamalai Deepam: 26-11-1985, Tuesday; 04-12-1987, Friday (Malai and Vaikanasa).
Karthigai Deepam: 27-11-1985, Wednesday (Vaikanasa and Panjaratra) ); 05-12-1987, Saturday (Panjaratra)
Vaikunta Ekadesi: 23-12-1985, Monday; 10-01-1987, Saturday; 31-12-1987, Thursday.
Arudra Dharshan: 27-12-1985, Friday; (17-12-1986, Wednesday; 04-01-1988, Monday).
Reference:
Panjangams for 1985 and 1987.

2011-2012 Raasi Phalalu – Mesham

2011-04-02T08:18:00.000-07:00

Auto Draft

2010-10-31T02:54:00.000-07:00

Telugu Samethalu Starting with ‘A’

2010-04-16T05:08:00.000-07:00

Aa thaanu mukkae !!!
Aada pilla, siggu billa paluvuri
lo kanipincha raadhu.
Aadaboina theerthamu yedurainatlu.
Aadadaani vayasu magavaani sampaadana
adagoddannattu.
Aadadi saadhinchalenidi ledu, mukhyanga mogudini.
Aadaleka maddela vodu annatlu.
Aadi lonae hamsa paadhu.
Aadi tappa raadhu, paliki bonka raadhu.
Aakaasaaniki hadde ledhu.
Aakali ruchi yerugadui, Niddura sukham yerugadu,
Valapu siggu yerugadu.
Aakali vaesthe rokali mingamannaadta.
Aaku yegiri mullu meeda padda, mullu vachi aaku meeda padinaa chirigedi aakae.
Aalasyam amrutham visham.
Aalu laedhu, choolu laedhu, koduku paeru somalingam.
Aarae dheepaaniki velugu yekkuva.
Aarogyamae mahaabhaagyamu.
Aasa laavu, peeka sannam (Contributed by Varma).
Aasthi mooredu aasa baaredu.
Aathraagaaniki buddhi mattamu.
Aavalinthaku anna unnadu kaani, thummuku thammudu laedanta.
Aavalisthe pegulu lekka pettinatlu..
Aavu chaenu maestae, dooda gattu maesthundaa?
Aavu gattuna mesthe dooda polaana mestundaa?
Aayane vunte mangali enduku ? (in olden days, women had to shave their heads if their husband dies, so "if he is alive, why need a barber")
Aayane vunte tella cheera enduku ? (contributed by Giri Babu, Srikakulam)
Abaddhamu aadina athikinatlu undali.
Abyaasamu koosu vidya.
Acchigaadi pellilo bucchigaadi ki oka Janjhapu pogu.
Adadhi anukunte Gadapaku teleekunda Dhantuthundhi
Adadhi anukunte gadapaku teleekunda dhatuthundhi
Adagandey ammaina annam pettadanta.
Adaganidhae ammainaa pettadhu.
Adakatteralo poka chekka laga (Rama Dayakar Reddy, Kadapa)
Adavari matalaku arthale verule.
Adavari notlo avaginja dhagadhu
Adavi kaachina vennelalaa (Like light in the jungle - useless).
Adavilo pelliki Jantuvulae purohitulu.
Addaalu naadu biddalu kaani, gaddalu naadu kaadhu.
Addham abaddham cheppadhu.
Addham eppudu abadham aadadhu, elantivadinainaa andamga chupisthundi. (Contributed by Rama Rao Vemulakonda)
Adigae vaadiki cheppaevaadu lokuva.
Adigo puli ante idigo thoka antaaru.
Adukkuney vaadiki cheppulu kuttukuney vaadu.
Adukkunnamma ku 60 kooralata, vandukunna ammaku okate koorata.
Adusu tokkanela kaalu kadaganela.
Ae endaku aa godugu.
Aemi laeni yedaarilo aamudamu chettae mahaa vrukshamu.
Agadthalo padda pilliki adae vaikuntamu.
Agniki aajyam posinatlu.
Agniki vaayuvu thodainatlu.
Aishwaryamu vastae artha raathri godugu pattamanaevaadu.
Akka pelli kukka chaavuki vachindi.
Akulu naakkunae vaadi daggara mootulu naakkunae vaadata.
Amaayakuniki akshintalu isthae aavalaki velli notlo vesukunnadata.
Ambali naaketodiki meesaalettetodu okadu.…
Ambham lo kumbham laa.
Amma kadupu chustundi, pellam jebu chustundi.
Amma petta pettadu .... Adukkutinanivvadu (Contributed by : Aruna)
Ammabothe adivi konabothe korivi laaga undi (Cherukuru Srinivas, Nellore)
Andani draaksha pallu pullana (Contributed by Vijay Phanidhar, Jammalamadugu)
Andham annam pettadu.
Andhani mraanipandlaku arrulu chaachuta.
Andhuni mundu andaalela ? (Why expose beauty before a blind man ?)
Andithe siga andhaka pothe kaallu.
Angatlo annee unnaa, alludi notlu seni unnatlu.
Anna daanam kante vidya daanam goppadi
Annam parabrahma swaroopam.
Annapraasana nadae avakaya patchadi.
Annapu choravae gaani aksharapu chorava laedhu.
Annee vunna vistharaaku anigimanigi undhata..yemi leni vistaraaku egiregiri paddadata…
Anni daanamulalo vidya daanam goppadi
Anni telisinamma amavasya nadu chasthe emi teliyanamma ekadasi nadu chacchindi.
Anni vunna alluni notlo shani vundi annatlu.
Anthata baave kaani vanga thota kaada kaadhu.
Antya nishtooram kanna aadhi nishtooram maelu.
Anumaanam penubhootam.
Appichchuvadu vaidyudu antaru.
Appu chaesi pappu koodu.
Ardharaatri maddeladaruvu.
Asale ledante pesarapappu vandamannaadata okadu.
Asalu baabu kanna...guddi baabu melu annattu…
Asalu kante vaddi ante preeti ata…
Asaluke esaru pettinatlu.
Asamarthudiki avakasamivvanela ?(Why give a chance to inefficient person ?)
Asapothu brahmadu lecipothoo pappu adigaaduta.
Athi rahasyam batta bayalu.
Attha leni kodaluttamuraalu, kodalu leni atta gunavanturaalu.
Attha meeda kopam dutta meeda choopinatlu
Attha sommu alludu daanam.
Avaginjanta abaddham mundu airavatamanta nijam kooda nilabadadu (Dr Talluri Sreedhar)
Ayina vaariki aritaakullo......kaani vaariki kanchaalallo.
Ayithe aadivaaramu, kaakunte somavaaramu.
Ayya vachhae varaku amaavaasya aaguthundha ?
Ayyagaari (brahmin) pillalatho aadunkuuna debbale, aadakunnaa debbale.(K Dasaradha Rami Reddy, Bangalore)
Ayyaki leka adukku tintuntae, koduku vachi kodi palaav adigaadata.
Ayyavaarini cheyyabothae kothi ayyinattlu.

2010-04-03T11:14:00.000-07:00

This preview ebook contains six chapters in three parts (153 pages total):

Part I   Getting Started

Chapter 1   Phone Hardware + Your Software

Chapter 2   Hello, Windows Phone

Part II   Silverlight

Chapter 3   Code and XAML

Chapter 4   Presentation and Layout

Part III   XNA

Chapter 5   Principles of Movement

Chapter 6   Textures and Sprites

Here’s a quick excerpt from the ebook:

Chapter 1
Phone Hardware + Your Software

Sometimes it becomes apparent that previous approaches to a problem haven’t quite worked the way you anticipated. Perhaps you just need to clear away the smoky residue of the past, take a deep breath, and try again with a new attitude and fresh ideas. In golf, it’s known as a “mulligan”; in schoolyard sports, it’s called a “do-over”; and in the computer industry, we say it’s a “reboot.”

A reboot is what Microsoft has initiated with its new approach to the mobile phone market. On February 15, 2010, at the Mobile World Congress in Barcelona, Microsoft CEO Steve Ballmer unveiled the Microsoft Windows Phone 7 Series and promised a product introduction in time for year-end holiday shopping. With its clean look, striking fonts, and new organizational paradigms, Windows Phone 7 Series not only represents a break with the Windows Mobile past but also differentiates itself from other smartphones currently in the market.

For programmers, the news from Barcelona was certainly intriguing but hardly illuminating. Exactly how do we write programs for this new Windows Phone 7 Series? Developers detected a few hints but no real facts. The really important stuff wouldn’t be disclosed until mid-March at MIX 2010 in Las Vegas.

Silverlight or XNA?

Intelligent speculation about the application platform for the Windows Phone 7 Series has gravitated around two possibilities: Silverlight and XNA.

Since about 2008, programmers have been impatiently awaiting the arrival of a mobile version of Silverlight. Silverlight, a spinoff of the client-based Windows Presentation Foundation (WPF), has already given Web programmers unprecedented power to develop sophisticated user interfaces with a mix of traditional controls, high-quality text, vector graphics, media, animation, and data binding that run on multiple platforms and browsers. Many programmers thought Silverlight would be an excellent platform for writing applications and utilities for smartphones.

XNA—the three letters stand for something like “XNA is Not an Acronym”—is Microsoft’s game platform supporting both 2D sprite-based and 3D graphics with a traditional game-loop architecture. Although XNA is mostly associated with writing games for the Xbox 360 console, developers can also target the PC itself, as well as Microsoft’s classy audio player, the Zune. The 2009 release of the Zune HD particularly seemed to suggest a mobile future built around the device’s revamped graphics and multitouch navigation. For many Zune HD users, the most disappointing feature of the device was its inability to make phone calls!
Either Silverlight or XNA would make good sense as the application platform for the Windows Phone 7 Series, but the decision from Microsoft is:

Both!

The Windows Phone 7 Series supports programs written for either Silverlight or XNA. And this we call “an embarrassment of riches.”

You can download the ebook in XPS format here. Here it is in PDF format. And the zipped code samples for this draft preview are here.

Charles is at MIX; say hello and ask him about programming for the Windows Phone. And enjoy, everybody!

[tweetmeme only_single="false"]

Use the Shift Key to Temporarily Disable Startup Applications for Troubleshooting

2010-03-04T06:31:00.001-08:00

Problems with applications that run at startup can cause logon delays or even prevent you from completing Windows startup in normal mode. One way you can simplify your configuration is to disable startup applications

By holding down the Shift key during the logon process, you can prevent the operating system from running startup programs or shortcuts in the following folders:

%SystemDrive%\Users\username\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
%SystemDrive%\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup

To disable the applications or shortcuts in the preceding folders, you must hold down the Shift key until the desktop icons appear. Holding down the Shift key is a better alternative than temporarily deleting or moving programs and shortcuts, because this procedure affects only the current user session.
To use the Shift key to disable applications and shortcuts in startup folders, log off the computer and then log on again. Immediately press and hold down the Shift key. Continue to hold down the Shift key until the desktop icons appear. If you can log on successfully, you have isolated the cause of the problem to your startup applications. Next, you should use the System Configuration utility to temporarily disable applications one by one until you identify the cause of the problem. With the cause of the problem identified, you can fix the applica¬tion or permanently remove it from your startup programs.

Use the Shift Key to Temporarily Disable Startup Applications for Troubleshooting

2010-03-04T06:31:00.000-08:00

By holding down the Shift key during the logon process, you can prevent the operating system from running startup programs or shortcuts in the following folders:

%SystemDrive%\Users\username\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
%SystemDrive%\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup

Add Take Ownership Option To Explorer Right Click Context Menu In Windows Vista Or In Windows 7

2010-03-03T08:58:00.001-08:00

If you hold down Shift key while right clicking on any file in Windows Vista or Windows 7 explorer, you can see few more options in the context menu.You can easily add one more option to the file context menu called “Take Ownership” option which will be very useful to take ownership of any file.As many of you know, we need to take the ownership of system file in Windows Vista or in Windows 7 that you want to alter by any means. You need to have the ownership to do even simple operations like Renaming and Replacing of files and folders in Windows Vista or in Windows 7.

To enable “Take Ownership” option in file context menu in Windows Vista or in Windows 7:

Open the Notepad editor from Windows Vista/Windows 7 start menu and copy the code given below:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\*\shell\runas]
@=”Take Ownership”
“Extended”=”"
“NoWorkingDirectory”=”"

[HKEY_CLASSES_ROOT\*\shell\runas\command]
@=”cmd.exe /c takeown /f \”%1\” && icacls \”%1\” /grant administrators:F”
“IsolatedCommand”=”cmd.exe /c takeown /f \”%1\” && icacls \”%1\” /grant administrators:F”

[HKEY_CLASSES_ROOT\Directory\shell\runas]
@=”Take Ownership”
“Extended”=”"
“NoWorkingDirectory”=”"

[HKEY_CLASSES_ROOT\Directory\shell\runas\command]
@=”cmd.exe /c takeown /f \”%1\” /r /d y && icacls \”%1\” /grant administrators:F /t”
“IsolatedCommand”=”cmd.exe /c takeown /f \”%1\” /r /d y && icacls \”%1\” /grant administrators:F /t”

Save the above code in notepad as ‘TakeOwnerShip.reg‘ to the computer.
Browse the saved file and then right click to the file and from the opening context menu select merge.
Continue through the UAC(User Account Control) prompt and confirm that you wish to perform the action.
After merging the entries to the Windows Vista/Windows 7 registry, reboot your system.
When you hold shift and right-click on a file or folder you will have the option of changing the ownership.
Please note that before the ownership will be changed, you must grant access(UAC Prompt), click Continue.

In order to verify that the “Take Ownership” option is successfully added to Windows Vista/Windows 7 explorer context menu, you can right-click on a file or folder, choose Properties and then choose Details and you will see the “Owner” section changed to COMPUTERNAME\USERNAME.

Add Take Ownership Option To Explorer Right Click Context Menu In Windows Vista Or In Windows 7

2010-03-03T08:58:00.000-08:00

To enable “Take Ownership” option in file context menu in Windows Vista or in Windows 7:

Open the Notepad editor from Windows Vista/Windows 7 start menu and copy the code given below:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\*\shell\runas]
@=”Take Ownership”
“Extended”=”"
“NoWorkingDirectory”=”"

[HKEY_CLASSES_ROOT\Directory\shell\runas]
@=”Take Ownership”
“Extended”=”"
“NoWorkingDirectory”=”"

Save the above code in notepad as ‘TakeOwnerShip.reg‘ to the computer.
Browse the saved file and then right click to the file and from the opening context menu select merge.
Continue through the UAC(User Account Control) prompt and confirm that you wish to perform the action.
After merging the entries to the Windows Vista/Windows 7 registry, reboot your system.
When you hold shift and right-click on a file or folder you will have the option of changing the ownership.
Please note that before the ownership will be changed, you must grant access(UAC Prompt), click Continue.

Activate Hidden Windows 7 Administrator Account

2010-03-03T08:57:00.000-08:00

Similar to former operating system Windows Vista, Microsoft’s new OS Windows 7 also has a built-in administrator account which is created when it is installed and it is disabled by default.Whenever you want to perform tasks under the administrator account with no UAC (user account control) in Windows 7, you need to enable the administrator account.You can go through this grand Administrator account to solve a problem or blocking rights, or simply activate it and keep it in reserve in case. You can enable the hidden administrator account in Windows 7 by any of the following three methods:

Method 1:Using Command Prompt

Open an elevated Command prompt in Windows 7 by right click on the command prompt and select “Run as Administrator”.After that you only need to enter the simple command below to activate it.

net user administrator /active:yes

You can also specify your password for this particular account by using the following command

net user administrator password

where you can replace “password” with your own password. You can see the account immediately after you logoff your Windows 7. In order to deactivate it, you can use the command below

net user administrator /active:no

This will effectively turn off the administrator account in Windows 7.

Method 2:Using Local Security Policy

Another way of activating the administrator account in Windows 7 is via Local Security Policy.

Type secpol.msc in the search bar and hit enter.
After the Local Security Policy pops up, navigate to Local Policies-> Security Options
You can see an entry that reads Accounts: Administrator account.
Double click the entry to enable it.

Method 3:Using Computer Management Policy

Another way of activating the administrator account in Windows 7 is via Computer Management Policy.

Type compmgmt.msc in the search bar and hit enter.
After the Computer Management window pops up, navigate to Local Users and Groups -> Users.
In right-side pane double-click on “Administrator” account. It’ll open its Properties.
Deselect “Account is disabled” option and Apply it.

Source:TomsTricks

Enable CTCP(Compound TCP) And ECN (Explicit Congestion Notification) In Windows Vista

2010-03-03T08:55:00.000-08:00

One significant addition to Windows Vista’s TCP/IP stack is CTCP or Compound TCP.CTCP(Compound TCP) is a technology that came out of the Microsoft Research group as a way to deal with connections that have a large bandwidth-delay product. This is because traditional TCP is inherently a conservative and well behaved system based on reliability and sharing as the most important properties.A good example of large bandwidth-delay type of connection would be satellite internet or wireless technology like EVDO or WiMax.This “secret” advanced networking feature disabled by default in Windows Vista. You need to have Auto-Tuning enabled for this to work.

ECN (Explicit Congestion Notification) is a mechanism that provides routers with an alternate method of communicating network congestion. It is aimed to decrease retransmissions. In essence, ECN (Explicit Congestion Notification) assumes that the cause of any packet loss is router congestion. It allows routers experiencing congestion to mark packets and allow clients to automatically lower their transfer rate to prevent further packet loss.ECN (Explicit Congestion Notification) is disabled by default in Windows Vista, as it is possible that it may cause problems with some older routers that do not support this feature.

Open a command prompt as an administrator(elevated command prompt) in Windows Vista or you will get an error that request needs to be elevated.

To Enable CTCP(Compound TCP) in Windows Vista run the following command in an elevated command prompt:

netsh interface tcp set global congestionprovider=ctcp

To Disable CTCP(Compound TCP) in Windows Vista run the following command in an elevated command prompt:

netsh interface tcp set global congestionprovider=none

To Enable ECN (Explicit Congestion Notification) in Windows Vista run the following command in an elevated command prompt:

netsh int tcp set global ecncapability=enabled

To verify changes,run the following command in an elevated command prompt:

netsh int tcp show global

Notes:

If you are going to use CTCP(Compound TCP) on a lossy connection that might have packets come back out of order, you might also want to enable RFC 1323 timestamps, unless you are on a very low bandwidth connection. You can do that by running ‘netsh interface tcp set global timestamps=enabled‘ in an elevated command prompt.
“Large bandwidth-delay product” usually means there is a very busy (congested) network or a connection that has a long trip to make (like satellite).

Source: TomsTricks

Increase DNS Cache In Windows Vista For Faster Web Browsing

2010-03-03T08:54:00.000-08:00

About Windows DNS Cache:

Windows uses a cache called DNS cache to store recently visited websites ie,Windows operating system puts the DNS information into a local DNS cache on your PC when you visit a site. You can see what your computer stores in this cache by going to Windows Vista Start > Run and typing cmd (the command prompt). Now type ipconfig/displaydns. You should see a list of all the website addresses it has stored in the cache.

Working of Windows DNS Cache:

Whenever you go to a website, it has to look up the IP address where that website is located. First it checks to see if it’s in your cache before asking the DNS server over the Internet for the IP address.The cache contains both negative and positive entries. Positive entries are those in which the DNS lookup succeeded and you were able to connect to the Web site. When Windows looks in the cache, if it finds a positive entry, it immediately uses that DNS information and sends you to the requested Web site. As you can see, referring to the address when you already have it is going to be faster than if it has to travel over the wires to retrieve it.

Negative entries are those in which no match was found, and you end up getting a “Cannot find server or DNS” error in your browser. Similarly, when Windows looks in the cache and finds a negative entry, it gives you the error message without bothering to go out to the site.Negative entries can lead to problems. When you try to make a connection to a site that has a negative entry in your cache, you’ll get an error message, even if the site’s problems have been resolved and it’s now reachable.

The items in the cache do not stay there forever, and are constantly making room for more recent addresses you visited. Increasing the size of the DNS cache in Windows Vista will allow for faster web browsing, especially if you frequently view the same websites. Edit some registry values to achieve this.

Click Start, type regedit in the Windows Vista Start search box, and then press ENTER.
Locate and then expand the following registry subkey:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Dnscache\Parameters

Go to New > DWORD (32-bit) Value.
Name it as CacheHashTableBucketSize
Double-click into it and enter the value 1
Also create the following DWORD values with the following values:

NegativeCacheTime = 0
CacheHashTableSize = 384
MaxCacheEntryTtlLimit = 64000
MaxSOACacheEntryTtlLimit = 301

Close the Windows Vista registry editor window and restart your computer for the changes.

Note: To make the change take effect flush your Windows DNS cache by issuing the command ipconfig /flushdns at an elevated command prompt. The command will flush your DNS cache — all the entries, both positive and negative, will be flushed — and it will be empty until you start visiting Web sites. Negative entries, however, will not be added to the cache if you’ve given the DWORD a value of 0.

Source : Tomstricks

Increase The Speed Of Internet Connection By 20% In Windows Vista

2010-03-03T08:53:00.000-08:00

Fact: Windows Operating System uses 20% of your internet connection bandwidth by default!

Reason: Windows reserves 20% of your available bandwidth for several reasons related to QoS or Quality of Services like Internet telephone systems, video, and also Windows Updates.

Resolution: But there is a simple trick to utilize your full internet bandwidth . You can use this trick to accelerate your internet speed.Here’s how to get it back.

Go to Windows Vista Start Menu > Run and then type “gpedit.msc” to run Group Policy Editor.
You’ll need to provide administrative confirmation if User Account Control(UAC) is turned on.
Go to Local Computer Policy > Computer Configuration > Administrative Templates.
Under Administrative Templates, expand Network and then Qos Packet Scheduler.
In the right panel, right click on Limit reservable bandwidth and then select Properties.
In Limit reservable bandwidth Properties, click on Setting tab and then enable Limit reservable bandwidth.
Here you can change Bandwidth Limit from default 20 to 0.

Note: By default, the Packet Scheduler limits the system to 20 percent of the bandwidth of a connection, but you can use this setting to override the default. This setting will allow the system to reserve nothing, rather than the default 20%.

Now , go to your Connection properties, select Networking and be sure Packet Scheduler is enabled .
Click ok and the restart your computer.

Notes:

The Quality of Service Packet Scheduler is a Windows platform component that is enabled by default on Windows Vista and Windows XP computers. This scheduler is designed to control the IP traffic for various network services, including Real Time Communications traffic. This component must be installed and enabled if the QoS markings described earlier for audio and video traffic are to be implemented by the IP stack.
QoS allow you to measure bandwidth, detect changing network conditions (such as congestion or availability of bandwidth), and prioritize or throttle traffic.
Disabling or lowering the reserved percentage to much can cause problems with applications that rely on it. For example, with streaming media or VoIP(Voice Over IP) applications.
Group Policy Editor (gpedit.msc) is not available in Windows Vista Home and Vista Home Premium editions
This trick is applicable to Windows XP Pro also.

Source: tomstricks

Tuning a Parallel LINQ File Search Application

2010-02-10T09:03:00.001-08:00

This post explores the performance issues that arise when using PLINQ to parallelize queries, and illustrates how the Concurrency Visualizer in Visual Studio 2010 can be a valuable tool in identifying performance bottlenecks and making efficient and profitable parallelization choices. The subject of this entry is a toy application that scans a set of files for a user-specified pattern and performs some processing every time it finds an occurrence of the pattern. The processing in this case is a simple count of the number of matches. In spite of its small size, the application provides insight into several issues that arise in parallelization using PLINQ.

Figure 1: Sequential version of the scan algorithm. The LINQ query is highlighted.

The starting point is a sequential version of the search algorithm expressed using LINQ shown in figure 1. Arguments to the function specify the pattern to be searched, as well as the files that are to be searched from a starting path and a pattern of searchable files. The code queries all lines in all applicable files for the pattern specified. A Stopwatch is used to measure the time consumed in this region. Also note the use of a “scenario marker" to identify and demarcate the interesting search region in the Concurrency Visualizer. The use of scenario marker is explained in detail in a previous blog entry.

This application is profiled in Visual Studio 2010 Concurrency Visualizer. Since the topic of this entry is to understand the parallelization of CPU-intensive LINQ fragments, the application makes three successive calls to Scan function with the same arguments so that virtual memory and page files are warmed up. This entry focuses on the third call to the Scan function. Improving performance bottlenecks posed by the blocking that arises due to disk reads/writes is a separate topic and is not the focus of this entry. The application is profiled in Concurrency Visualizer when scanning ~5000 files, each containing at most a few thousand lines of text, for a reasonably complicated regular expression. Scenario marker "GrepMarker" demarcates the region of interest.

Figure 2: Threads view of the sequential scan region. Irrelevant threads are hidden using the "hide threads" functionality of Concurrency Visualizer. A scenario marker helps zoom in on the important region.

Figure 2 shows the "threads view" after zooming in on GrepMarker region and selecting the marker. As shown in the figure, the region takes ~6.9 seconds and is executing (green) most of this time. Figure 3 shows the CPU utilization view of the same Scan region. As expected, the application fails to use up more than one CPU at any stage, and is compute-bound, resulting in almost a 100% CPU utilization the entire time.

Figure 3: CPU utilization view of the scan region. The application is CPU-bound and might benefit from parallelism to take advantage of available cores.

Figure 4: Execution report of the scan region.

Figure 4 shows the execution report for the scan segment. This shows that almost 75% of the compute cycles are spent in the Regex.Match function, which does pattern matching. The remaining time is spent in reading files, listing directories, in garbage collection, etc. The report shows that there is much potential for improving performance through parallelism. The key is that while the processing on each file is hard to parallelize (it is most natural to read and process lines within a file sequentially), different files can be searched in parallel. Figure 5 shows how to achieve this using PLINQ, by adding a ".AsParallel" directive to the query so that each file is processed in parallel. PLINQ hides away the management required to create threads, partition the work between threads, and collecting the results.

Figure 5: Converting LINQ to PLINQ for parallel performance by adding a .AsParallel directive at the end.

Figure 6 shows the threads view when this parallel version of scan is profiled on the same machine, which is a 4-core system. PLINQ allocates the work to four worker threads, while the main thread processes results as and when they become available. This first attempt at parallelism reduces the time from 6.9 seconds initially to 3.7 seconds, a 1.8x speedup.

Figure 6: Threads view of parallel Scan. The outer marker is the “GrepMarker” scenario marker, while the marker nested inside it identifies the region executing PLINQ code.

The figure also gives insight into why this version did not yield even more speedup. A major bottleneck is the initial sequential portion of the query, which is spent executing Directory.GetFiles, readily identified by examining stacks and execution report for this segment. Another major reason is the load imbalance between the four worker threads, where worker thread 10532 finishes the earliest and thread 9664 finishes the last, delaying completion of the query for almost a second. This is further confirmed by examining the CPU execution view as shown in figure 7. The view clearly illustrates the sequential bottleneck regions that limit gains from parallel performance.

Figure 7: CPU execution view of parallel Scan. Sequential bottleneck regions are circled out.

The initial sequential execution is due to the fact that the call to Directory.GetFi
les needs to get the names of all files before it returns an array containing those names. In the sequential version, this operation took only 7.1% of the execution time, but following Almdahl's law, it becomes a limiter to parallel performance. The second sequential bottleneck (circled in the latter part of the region) is due to load-imbalance between the threads executing the query. The load-imbalance problem arises because PLINQ performs range partitioning on the array, assigning equal number of files to each thread, as explained here. This leads to poor partitioning since files are of different length, and require different amounts of processing and simply allocating equal number of files to each partition need not result in a good distribution.

A better parallelization can be achieved by replacing the call to Directory.GetFiles by Directory.EnumerateFiles. This returns an enumerator, and the file enumeration can now proceed in parallel with processing of other files.

Figure 8: Alternative file enumeration strategy for PLINQ based Scan.

Figure 9 shows the result of profiling the resulting version in Concurrency Visualizer, and the region demarcated by scenario marker is selected. In this version, the execution time is ~2.4 seconds which is a 2.9x speedup over the initial sequential version.

Figure 9: Threads view for parallel Scan version 2.

Figure 10 shows the CPU utilization view for this version of scan. Largely, the performance is limited by other processes, or the system doing file system operations on behalf of this application.

Figure 10: CPU utilization view for parallel Scan version 2.

However, there are a few sequential regions that limit even further performance gains. Going back to the threads view, there is non-trivial amounts of blocking. Clicking on such regions gives the detailed blocking stack, as well as what unblocked it. Figure 11 shows the blocking stack for one such region, where three of the worker threads are blocked waiting for the fourth thread. Examining the stack provides some hints into what causes this blocking. The blocking arises due to the chunk partitioning strategy in PLINQ which starts out with a small chunk size, and attempts to grow the chunk size based on application behavior. This particular region was one where the chunk size was increased. Due to this, one thread was enumerating the files and the remaining worker threads were waiting on a lock to be allocated their chunks. This seems to be a one-time thing though, subsequently PLINQ adapted well to the application.

Figure 11: Details of blocking stack for one region in parallel scan version 2.

Figure 12 shows the report summarizing reasons for blocking during this entire period, and file enumeration for chunk partitioning accounts for 0.47 out of the 1.1 second blocked time in the scan period. The remainder of blocked time was spent mainly in garbage collection, something seen by further expanding the report.

At this point, one could spend further time trying to write a custom PLINQ partitioning scheme to reduce the blocking time from chunk partitioning, as well as trying to reduce garbage collection time by selecting a server garbage collector or by using a memory profiler to weed out memory hogs. But already, a 2.9x improvement in performance is quite significant for pretty minimal set of changes to the application code. While changes to code were minimal in this case, Concurrency Visualizer was an important tool in this process to help identify the right set of changes needed and to identify bottlenecks.

Further links:
LINQ:
http://msdn.microsoft.com/en-us/netframework/aa904594.aspx
http://msdn.microsoft.com/hi-in/library/bb308961%28en-us%29.aspx

Parallel Computing
http://msdn.microsoft.com/en-us/concurrency/default.aspx

Parallel Programming in .NET Framework
http://msdn.microsoft.com/en-us/library/dd460693%28VS.100%29.aspx

Parallel LINQ
http://msdn.microsoft.com/en-us/library/dd460688%28VS.100%29.aspx
http://blogs.msdn.com/pfxteam/

Concurrency Visualizer
http://msdn.microsoft.com/en-us/library/dd537632%28VS.100%29.aspx
http://blogs.msdn.com/visualizeparallel/

Tuning a Parallel LINQ File Search Application

2010-02-10T09:03:00.000-08:00

Figure 1: Sequential version of the scan algorithm. The LINQ query is highlighted.

Figure 3: CPU utilization view of the scan region. The application is CPU-bound and might benefit from parallelism to take advantage of available cores.

Figure 4: Execution report of the scan region.

Figure 5: Converting LINQ to PLINQ for parallel performance by adding a .AsParallel directive at the end.

Figure 6: Threads view of parallel Scan. The outer marker is the “GrepMarker” scenario marker, while the marker nested inside it identifies the region executing PLINQ code.

Figure 7: CPU execution view of parallel Scan. Sequential bottleneck regions are circled out.

Figure 8: Alternative file enumeration strategy for PLINQ based Scan.

Figure 9: Threads view for parallel Scan version 2.

Figure 10 shows the CPU utilization view for this version of scan. Largely, the performance is limited by other processes, or the system doing file system operations on behalf of this application.

Figure 10: CPU utilization view for parallel Scan version 2.

Figure 11: Details of blocking stack for one region in parallel scan version 2.

Further links:
LINQ:
http://msdn.microsoft.com/en-us/netframework/aa904594.aspx
http://msdn.microsoft.com/hi-in/library/bb308961%28en-us%29.aspx

Parallel Computing
http://msdn.microsoft.com/en-us/concurrency/default.aspx

Parallel Programming in .NET Framework
http://msdn.microsoft.com/en-us/library/dd460693%28VS.100%29.aspx

Parallel LINQ
http://msdn.microsoft.com/en-us/library/dd460688%28VS.100%29.aspx
http://blogs.msdn.com/pfxteam/

Concurrency Visualizer
http://msdn.microsoft.com/en-us/library/dd537632%28VS.100%29.aspx
http://blogs.msdn.com/visualizeparallel/

Using the Concurrency Visualizer to Analyze MPI Communication Overheads

2010-02-10T09:01:00.001-08:00

The Message Passing Interface (MPI) is a popular API for developing message-passing based parallel applications on clusters. Microsoft has a Windows HPC Server product that includes an implementation of MPI, among other things (visit http://www.microsoft.com/hpc). In this post, I’d like to demonstrate how the Visual Studio Concurrency Visualizer can be used to efficiently identify MPI communication overheads on the Windows HPC Server platform. Before I start, I’d like to acknowledge the help of some colleagues of mine, Jeff Baxter, Mayank Agarwal, Matthew Jacobs, and Paulo Janotti, who helped me prepare the material for this post.

One of the difficulties in analyzing MPI overheads using the Concurrency Visualizer is that the runtime system may use polling to reduce communication latency on some network platforms that support it. This hides what are logically blocking operations from the tool, making it difficult for the Threads view to illustrate exactly how often threads block waiting for messages, barriers, or reduction operations and where those events take place in the application code. Instead of showing these as blocking events, they will appear to be green execution segments in the tool. Although the Execution profile report will usually show these costs, they can be difficult to pinpoint as they may account for a small fraction of total samples. Even on network implementations where polling is not used (e.g., pure Gigabit Ethernet), blocking on MPI network communication might appear as blocking on synchronization or some other category.

In order to make MPI communication analysis easier on developers, we’ve included special support in the Concurrency Visualizer to show MPI delays in the I/O category. Here are the steps necessary to accomplish this:

1. Install the command-line profiling tools on one of your cluster compute nodes. This requires running the installer from the \Standalone Profiler\x64\vs_profiler.exe on your Visual Studio Premium or Ultimate DVD (or the ISO image for Beta 2). You also need to install .NET 4.

2. In order to enable the Concurrency Visualizer MPI functionality, you need to disable polling in the MPI runtime. This can be accomplished by supplying a special environment setting when launching your MPI application, as shown in the following command:

job submit /numcores:8 mpiexec –env MPICH_PROGRESS_SPIN_LIMIT 1 …executable_path..

Note that setting the MPICH_PROGRESS_SPIN_LIMIT environment variable is the special sauce that you’ll need to address the spinning vs. blocking issue described above.

3. When you’re ready to profile your application, follow the instructions for the attach scenario using the command-line tools described in my blog here.

4. Copy the resulting .vsp and .ctl files to the machine that has Visual Studio 2010 Premium or Ultimate installed and open the .vsp file. Make sure that you have an appropriate symbol path that includes symbols for msmpi.dll (the Microsoft public symbol server should be sufficient).

To illustrate how an MPI profile looks like in the Concurrency Visualizer, let’s take a look at a simple Jacobi implementation with nearest neighbor communication at partition boundaries:

In the above CPU Utilization view, you’ll notice that the MPI process, which is supposed to consume 100% of a single core on average is only consuming about ~70-80% of a core. That’s usually an indication of either synchronization or I/O. In this case, since the MPI application is single threaded, I/O must be the culprit. Now here’s what the Threads view shows when we examine this run:

We now see some purple (I/O delays) mixed in with the green on the timeline that correspond to delays waiting on MPI messages. The legend also shows that 20% of the time is spent blocking on I/O, which makes sense based on what we saw in the CPU Utilization view. You can also see in the I/O report that all blocking MPI calls are clearly shown and the call stacks are collated and ordered to show you the most significant sources of delay (in this simple example, there’s only a single stack with an MPI_Sendrecv). As usual, you can jump straight from the reports to the source code in order to tune your application. If it wasn’t for the custom MPI experience in the Concurrency Visualizer, you might have observed various categories of blocking delays depending on the underlying kernel mechanisms used, instead of the MPI calls that are more intuitive from a programmer’s perspective.

You should be aware that changing from polling to blocking introduces some latency, so there’s a perturbation in execution, but when your application suffers from significant messaging overheads, it is sometimes an acceptable cost in return for better diagnostic feedback.

I hope that you’ll find this useful. Now go have some fun!

Using the Concurrency Visualizer to Analyze MPI Communication Overheads

2010-02-10T09:01:00.000-08:00

job submit /numcores:8 mpiexec –env MPICH_PROGRESS_SPIN_LIMIT 1 …executable_path..

Note that setting the MPICH_PROGRESS_SPIN_LIMIT environment variable is the special sauce that you’ll need to address the spinning vs. blocking issue described above.

3. When you’re ready to profile your application, follow the instructions for the attach scenario using the command-line tools described in my blog here.

To illustrate how an MPI profile looks like in the Concurrency Visualizer, let’s take a look at a simple Jacobi implementation with nearest neighbor communication at partition boundaries:

I hope that you’ll find this useful. Now go have some fun!

Maintaining a Consistent Application State with TPL

2010-02-10T08:46:00.000-08:00

The aim of this post is to help developers writing applications in which operations may need to be performed and then later undone due to a subsequent failure. It shows a pattern for how to maintain such a consistent application state by utilizing functionality from the Task Parallel Library (TPL) in the .NET Framework 4.

For the purposes of this blog post, a program/routine is a state machine where each state is equally valid and important and should be handled correctly regardless of whether it belongs to a happy path or not. Specifically, a step that rolls back an incomplete state transition is equally important as a step that makes a forward state transition. A lot could be written about the advantages and disadvantages of exceptions vs. error codes, and such a discussion is not the goal of this post: for the purpose of this article, it is only worth mentioning that throwing and catching exceptions is focused on the happy path (it keeps the code clean and easy to comprehend), while returning and checking error codes is focused on detecting the places of the code (program states) where deviations from the happy path may occur.

In general, a routine that consists of n atomic forward steps, where each forward step may fail and then needs to be undone, could be modeled as the following state machine:

Assuming a step is atomic means we don't have to undo that particular step if it fails. That is why the undo sequences in the diagram start with the last successful step.

Note: It is also assumed that undoing may not fail. If failures are possible to occur during rollback, then you should strongly consider using a real transactional resource manager like a database server.

Now that we've stated the problem, what is the best way to approach it? Obviously, there are solutions through either error checking or through exception handling, but both of those come at the expense of convoluting the code. Notice that the number of state transition paths is about three times the number of forward steps. Ideally, we are looking for a solution that has a clean happy path as well as clean undo paths without any if statements or separate Exception types for each forward step. In other words, we are looking for a way to describe a program as a state machine.

That's exactly what the TPL does through tasks (as states) and continuations (as state transitions).

Let's take a concrete application as an example and write some real code. Let's say we have a system that manages the process of making a sandwich. In a terminal state our resources, bread and ham, are in the fridge. (For the sake of simplicity, we produce one sandwich at a time.) First, we take a slice of bread out of the fridge. Second, we take a slice of ham out of the fridge. Third, we assemble the bread and the ham into a sandwich. If an operation fails, we have to return whatever ingredients are currently on the line back to the fridge so they don't rot:

And here is the code of our routine:

// HAPPY PATH

Task retrieveBread = Task.Factory.StartNew(RetrieveBreadFromFridge);

Task retrieveHam = retrieveBread.ContinueWith(_ => RetrieveHamFromFridge(),

TaskContinuationOptions.OnlyOnRanToCompletion);

Task assembleSandwich = retrieveHam.ContinueWith(_ => AssembleSandwich(),

TaskContinuationOptions.OnlyOnRanToCompletion);

// RESET STATE

TaskCompletionSource<bool> reset = new TaskCompletionSource<bool>();

assembleSandwich.ContinueWith(_ => reset.SetCanceled(),

TaskContinuationOptions.OnlyOnRanToCompletion);

// UNDO PATH

Task returnBread = new Task(ReturnBreadToFridge);

returnBread.ContinueWith(_ => reset.SetResult(true),

TaskContinuationOptions.OnlyOnRanToCompletion);

Task returnHam = new Task(ReturnHamToFridge);

returnHam.ContinueWith(_ => returnBread.Start(),

TaskContinuationOptions.OnlyOnRanToCompletion);

// HAPPY PATH -> UNDO PATH

// On a failure in bread retrieval - signal "reset".

retrieveBread.ContinueWith(_ => reset.SetResult(true),

TaskContinuationOptions.OnlyOnFaulted);

// On a failure in ham retrieval - return bread

retrieveHam.ContinueWith(_ => returnBread.Start(),

TaskContinuationOptions.OnlyOnFaulted);

// On a failure in sandwich assembly- return ham and bread

assembleSandwich.ContinueWith(_ => returnHam.Start(),

TaskContinuationOptions.OnlyOnFaulted);

// WAIT

// Log the execution of the HAPPY PATH tasks.

// Additionally, wait on the reset state to get signaled.

Task[] loggedTasks = new Task[]

{retrieveBread, retrieveHam, assembleSandwich, reset.Task};

Task.Factory.ContinueWhenAll(loggedTasks,LogErrors)

.Wait();

As you can see, there are no if statements, nor are there any Exception types customized to provide information what step failed.

Finally, I added a logging task that effectively waits for all the state machine tasks to finish, and then traverses the given task array and logs any error messages. (Notice that I still have to wait for that task to finish.) The body of that method is straightforward:

private void LogErrors(Task[] tasks)

{

Console.WriteLine("\n\tERRORS:");

foreach (Task task in tasks)

{

if (task.IsFaulted)

{

// Use the InnerException since it is wrapped in an AggregateException

Console.WriteLine("\t{0}", task.Exception.InnerException.Message);

}

In conclusion, TPL enables writing state-sensitive applications on the .NET platform without convoluting the application code with many if statements or customized exception types. While the code is still a little verbose, it closely resembles the state machine's diagram