Now I know you have tons of questions, but if you check out the webpage it explains everything in full detail.  The official rules are also there for you to read through and if that doesn't answer all your questions, our forum is a place where you can post questions and receive replies.  You can also comment below under this blog post - we read all of your comments!

Become a fan of the Challenge and then download our snazzy backgrounds for your computer!  The .zip file contains the Intel Atom Developer Challenge backgrounds in full screen (1600x1200), widescreen (1920x1200), netbook (1024x600) and a special Moblin netbook graphic (1024x600) to fit the interface.  Enjoy and share with others!

Also, if you're sharing or commenting on Twitter, our hashtag is #winanetbook! 

1. You will learn about the vPro architecture and components (like AMT/VT/TXT).
2. You will identify the Active Management Technology use cases and then you will probably find out how your solution addresses them.
3. You will discover opportunities to build new software to use AMT technology (like a power monitoring solution).
4. You will discover AMT features you haven’t used (I didn’t know AMT had a case instruction sensor!).
5. You will find new ways to perform certain tasks (Did you know about terminal scripting existence? – It’s useful to change many computer BIOS settings).
6. You will learn how some AMT components integrate with well-known technologies (like Active Directory).
7. You will learn how to address end user problems with any AMT functionality, for example: preventing a worm infection by pushing a network filter or repairing and updating security agents.
8. You will discover a way to detect that a console is talking to Intel AMT locally through LMS service.
9. You will find the difference between the SNMP traps and WS Eventing.
10. You will find samples on how to scan, connect and gather information of computers using Intel AMT. There are other useful samples like how to build a serial relay application to use a standard terminal like Putty or Microsoft Windows XP HyperTerminal.

Maybe you will find your own reasons and want read it twice! Then don't be shy and share them!

Javier Andrés Cáceres Alvis
Personal Blog: http://speechflow.spaces.live.com/
Intel Blog: http://software.intel.com/en-us/blogs/author/javierandrescaceres/

So that is exactly what he set out to do.  Here is an article about the work that he has done. http://www.stolaf.edu/news/index.cfm?fuseaction=NewsDetails&id=4769  Professor Brown has started to do what I hope all of you will, which is to THINK PARALLEL, and better yet start to TEACH PARALLEL.  Together we can all figure out the best curriculums and the best ways to teach these new curriculums.

I encourage all of you to come to the Intel Academic Community often to see what your fellow academics are working on. Let us know what you are working on, and share some of your curriculum.

SP1 is well worth downloading and installing - here are some of the reasons:

1. Parallel Inspector and Parallel Amplifier can be driven (for automating test suites) from the command line now.
2. Bug fixes - of course - not many issues needed fixing, but you may appreciate the ones bugs that were found and fixed!
3. Window 7 support (Parallel Studio came before Windows 7, now that it is released - we had a few things to update)
4. TBB 2.2 and other improvements to align with the upcoming Microsoft Visual Studio 2010 I'm sure there are more - these are the highlights as I see them.

Download SP1 - you'll be glad you did!

See the release notes for more details - skip the main document if you want to read about what is new and useful - read the three individual documents.

As I expected,  SC09 took most of Portland Expo floor space . Since I have my four-pages print out from SC Conference Activities, I was able to orient myself, and able to find Portland Ballroom for most of Paper and Technical sessions. Not surprisingly, I saw and heard a lot of voice and discussion in different languages, people with suit, tie and laptops. I was able to say hello and joined quite a discussions in Chinese, which is my first language, at exhibit hall, poster area and Ballroom. I  attended my first technical session ”Enabling Software Management for Multicore Caches with a Lightweight Hardware Support” presented by Jiang Lin, and Qingda Lu from Iowa and Ohio State Univ. about the management of shared caches in multi-core processors. In the article, a proposal of an affordable and lightweight hardware support to coordinate with OS-based cache management policies. The presenter concluded that the policies improve performance over LRU-based hardware cache management by 14.5% on 8-core systems. It was a good project.

Then I jumped into another ballroom in a less attended time for one of my interested, and bookmarked session on “On the Design of Scalable, Self-Configuring Virtual Networks” presented by David and Yonggang from Univ. of Florida on a novel Virtual Network design that supports dynamic, seamless addition of new resources with emphasis on scalability in a unified private IP address space. My interest attributed to the virtualization technology came from my group’s need to find an innovative way of supporting the parallel and multi-core programming education in academic classroom with realistic Hardware budget ( it is still the recession time for some of us right?). With our first parallelism integration with University of Southern California, providing maxima servers’ access for lab exercises with student/server ratio of more than 10 has to be done in an innovative way.

After two sessions, I also visited another interesting presentation: Space-Efficient Time-Series Call-Path Profiling of Parallel Applications presented by Zoltan etc. of Juelich Supercomputing Center. There is still one of my interested presentations that I could not make it on Thursday: Comparative Study of One-Sided Factorizations with Multiple Software Packages on Multi-Core Hardware  which will be presented by Emmanuel and Bilel etc of University of Tennessee, Knoxville).

Later, I went back to exhibit hall and started wandering through the most technology enriched IT professional/Server/laptop firm in the world. Passing through the amazing 1024 high definition movie streaming demo and almost zero latency 1024P Live broadcast from Tokyo Japan by Japan NTT, I came to a small booth, which has been my dream of “what I want to be  in future” kind of answer when I was a child: Institute of Computing Technology, Chinese Academy of Sciences, ICT is the cradle for China computer profession, having spun off new academic institutions and hi-tech companies(i.e. Lenovo) . Dawning 5000A Supercomputing System will be launched by this November, developed by ICT and Dawning Corp. under the support of Chinese Hi-tech Program, with 230 TFlops of peak performance and 160TFlops Linpack performance. All my following discussion at the booth is in Chinese.That seems to be the very productive time I spent, and the highlight of my experience at SC09.

About a hour later, I continued my brainstorming journey, paused at booths with brand names I saw everyday for some exhibit forum,  and ended at Microsoft boot for another long discussion ( stay tuned for my blog on it)

In this video from the Intel booth at OSCON, Paul Cooper, Moblin Apps and UI Engineering Manager at Intel, talks about the user experience on Moblin. The netbook as a mobile device with a smaller screen size, keyboard and trackpad provided particular challenges that had be considered when designing the user experience for Moblin.

You can read an interview with Paul for more details about the improvements they have made to the Moblin user experience, and we have many more open source videos on the multimedia page.

While massaging the data around to see how many machines use what kind of processor, one data point that stuck out for me was that Intel processors are in 402 of the 500. Obviously we're proud to be driving a large percentage of the highest performing platforms on the planet. One little thing that I found odd, though, was the raw numbers for IBM Power. Within the 52 Power-based machines, 1470752 cores are used. That is an average 28283 cores per platform. (The Intel average number of cores per platform is much smaller.)

The Performance Development charts are interesting, too. The historical data shows that my laptop would have been on the list in the mid-1990's. The Projected Performance Development chart predicts that we should be seeing exascale machines near the end of the next decade. (Estimates about the power needed to keep such a machine running have heightened the need and desire to find ways to lower the processor power requirements.)

What does it all mean? I don't know. There are so many ways you can spin all the gathered data that I better understand Mark Twain's remark from his "Chapters from My Autobiography", published in the North American Review, No. DCXVIII., July 5, 1907: "Figures often beguile me, particularly when I have the arranging of them myself."

To get answers I think you have to think outside “typical” PC gaming development. The opportunity is in how people use, work, and interact with these devices differently than say a traditional laptop or desktop systems. You don't have to stretch the imagination too far to understand the growth market and new gaming opportunities in the mobile space. Just look at the iPhone. Many of the most successful games on that platform are not your traditional polygon pushing games.

My last post looked at how casual games could be enhanced with “relax” modes; allowing gamers to have stress free casual gaming experiences. Similarly here, the message is good game play is not defined by to hardware specifications. Good games can be derived from the state of mind, tasks, & environment of gamers when using their device. As with the iPhone, Atom based devices are used in unique situations where there are unique gaming opportunities. If you consider how, when, where and why gamers use a companion PC device like a Netbook you can find new market opportunities for gaming.

Here’s my list of things developers should consider when creating new Atom based games:

• Quick and convenient game play:
  

  Zen Bound is a beautifully simplistic game for the iPhone that exploits how that device is used

  
  Your Atom based device is likely traveling with you, and the user will consider playing a game when they have down time between other activities while on the road. This doesn't mean games need to be short but they should accommodate gamers jumping in an out quickly
• Location aware:
  Because the gamer will be mobile, location aware features in games can add another dimension to games. There's a lot going on with augmented reality these days, and clever games can make use of locations and environments that mix with the game play to make interesting gaming experiences
• Focused tasked:
  Smaller screen sizes, can also lend to more focused tasks in games. Consider UI designs that are minimalized & focused over providing a swiss army knife of tools and tasks. Often focused game play can lead to stunning graphics and great gaming experiences. A great example of this is Zen Bound for the iPhone.
• Social play:
  Mobile computing devices are becoming popular because they allow you to easily stay connected with your network of friends. Beyond multi-user play, consider how to involve sharing and status updates with integration of email, Twitter & Facebook
• Asynchronous online play:
  With mobility being more connected, it may not mean always connected. Consider games that allow you play immediately then connect with the network between levels or games.

Additionally more than just creating new games, developing games for Atom provides these additional opportunities.

Mobile mini games could allow you to customize aspects of your PC games such as upgrading & modding vehicles, characters, & weapons

• Companion mini games of existing game titles:
  Often the same software will run your PC as will run on a gamer’s Intel based portable device. Consider levels, mini games, tasks, puzzles and vehicle configuration tools that a gamer can take on the road with them, then upload a status of their portable play to their PC game for experience points, level ups, weapons etc
• Component development:
  With Atom Developer Program, you can develop and sell game components for other developers to use. Many of the above items can be consider areas of component development. As well there will be many flavors in the hardware, some with multi-touch, some with webcams, etc. All opportunities to create components that will be valuable for developers

I’m sure there is much more to consider than my short list, especially when you look at various hardware options, but the point is we have an exciting time in front of us. If we focus on how people uniquely use Atom based devices we can find new opportunities to; create new exciting gaming experiences, extend the value of existing titles, and create gaming components that enable a marketplace of cool new game.

In other words Bring It!

Relevant Links

• Atom Developer Program
• Atom Developer SDK
• Follow Intel's Bob Duffy on Twitter

To get acquainted with new operator which does not generate exceptions see the article "Nothrow new". And here I will give only two examples which demonstrate the idea of the solution very clear.

The code with processing of an exception:

size_t errCount = 0;
#pragma omp parallel for num_threads(4) reduction(+: errCount)
for(int i = 0; i < 4; i++)
{
  try {
    float *ptr = new float[10000];
    // code
    delete [] ptr;
  }
  catch (std::bad_alloc &)
  {
    ++errCount;
  }
}

Simplified code without processing of exceptions:

size_t errCount = 0;
#pragma omp parallel for num_threads(4) reduction(+: errCount)
for(int i = 0; i < 4; i++)
{
  float *ptr = new(std::nothrow) float[10000];
  if (ptr == NULL) {
    ++errCount;
  } else {
    // code
    delete [] ptr;
  }
}

P.S. An interesting note by Dmitriy Vyukov:

"nothrow new" is somewhat a deceptive construction because first an impression occurs, that if I do write nothrow, this means that exceptions will not be thrown out of here. And then it turns out that it is not that simple, and exceptions will not be thrown out solely referring to the given memory allocation, but not to the constructor/constructors.
That is, if at least std::string is singled out; or a class containing std::string is singled out; or a class which by itself singles out memory by new, but now without nothrow, then exceptions to new(nothrow) construction will be thrown out anyway.
Though, of course, if an array of primitive types is singled out, as in the example, then exceptions will not be thrown out. However, malloc(), too, can be quite used here.

size_t nCount = 10;
int **poinerArray = (int **)malloc(nCount * 4);

The code is incorrect but in a 32-bit system it will work correctly. The error can occur when adapting the program to a different software/hardware environment. It has become very urgent and important to detect such a code because of mass migration of software on 64-bit systems. Changing of the sizes of some base types makes a code like this very dangerous. Viva64 analyzer included into PVS-Studio will show a warning about using magic constant “4″ on the code given above and an error will be detected when viewing the diagnostic warnings. But a code can be more complicated:

#define N_COUNT 100
#define POINTER_SIZE 4
#define NSIZE (N_COUNT * POINTER_SIZE)

int **pArray = (int **)malloc(NSIZE);

It is more difficult to diagnose an error in such a code written in C style with the use of #define. Although the code contains constant 4 defined by a macro, Viva64 analyzer is deliberately set so as to avoid showing warnings on such constructions. The analyzer ignores magic constants defined by macros (#define) due to two reasons. First, if a programmer defines constants through macros, he is likely to know what he is doing and a false response is very likely to occur. Second, if we react to constants which are dangerous from the viewpoint of a constant’s 64-bit mode (4, 8, 32 etc) we will have too many false responses relating to using Windows API. Let’s consider a harmless code as an example:

MessageBox("Are you sure ?",
           "Some question",
           MB_YESNO | MB_ICONQUESTION);

If we analyze the magic numbers hidden behind MB_YESNO and MB_ICONQUESTION macros there should be two warnings on using magic constants 4 and 32 on this line. Of course, it is too great a level of false responses. When analyzing malloc() function we can print all information about all dangerous magic constants without paying attention if it is a macro or not. But that is not enough anyway for the next case:

int **pArray = (int **)malloc(400);

If we go further and consider any number used in the expression for malloc() function unsafe it will cause false responses on a correct code:

int **pArray = (int **)malloc(400 * sizeof(int *));

On examining the situation, we have decided to introduce a new rule to verify applications whose result is transferred into malloc() function. At present, this rule reads as follows:

You should consider unsafe using numeric literals in the expression transferred into malloc() function. Exceptions:
1) The expression contains sizeof() operator
2) All the numeric literals divide by four with a remainder

Thanks to this rule we can warn about an error in the following code:
1) The first example:

void *p = malloc(nCount * 4);

2) The second example:

#define N_COUNT 100
#define POINTER_SIZE 4
#define NSIZE (N_COUNT * POINTER_SIZE)
int **pArray = (int **)malloc(NSIZE);

And also avoid showing a false warning on the code like:
1) The first example:

void *p = malloc(sizeof(double) * 4);

2) The second example:

#define N_COUNT 100
#define POINTER_SIZE sizeof(int *)
#define NSIZE (N_COUNT * POINTER_SIZE)
int **pArray = (int **)malloc(NSIZE);

This new diagnostic rule is most likely to appear in the next version of PVS-Studio 3.30. Let’s now consider another situation also relating to malloc() function and incorrect suggestion about data alignment. It is not quite relative to magic constants but the problem is similar. Let’s consider an example of code:

struct MyBigStruct {
  unsigned m_numberOfPointers;
  void *m_Pointers[1];
};
unsigned n = 10000;
void *ptr = malloc(sizeof(unsigned) +
                   n * sizeof(void *));

Although this code does not use magic numbers and the size of the types is defined by sizeof() the code is still incorrect. It does not take into account changing of the data alignment method different for 32-bit and 64-bit systems. The following code will be correct:

void *ptr = malloc(
  offsetof(MyBigStruct, m_Pointers) +
  n * sizeof(void *));

To warn the user about a possible error we are planning to introduce one more rule:

You should consider unsafe using more than one sizeof() operator in the expression transferred into malloc function. Perhaps, changing of alignment is not considered when calculating the structure’s size. With that, the parts of an expression split by the comparison or division operator are considered independently.

In some cases this rule will cause false responses but such places must be checked thoroughly anyway.
The dangerous expressions with magic constants described above are topical not only for malloc() function but for a class of such functions as fread, fwrite etc. But these functions must be studied separately and we will perform their analysis later when diagnosis relating to malloc() function is completely worked out.

Download an mp3 of show.

The News:

Intel® Parallel Studio Webinars - Live sessions are held at 9 a.m. PST/Noon EST.

• * Dec. 1: Bernard Laberge, Avid: A Quick and Easy Way to Parallelize a Legacy Codebase with Intel(r) Threading Building Blocks
• * Dec. 15: Matt Dunbar, SIMULIA: How to Use Intel® Parallel Studio to Streamline Code Development in a Multi-core Environment

Intel Threading Challenge PHASE 2

• Problem 1 - "Strassen's Algorithm" winner was iArchitect
• Problem 2 - "Knights Tour" winner is "mdm100"
• Problem 3 - "Graph Coloring" winner is "akki"
• Problem 4 - "The Traveling Baseball Fans" winner is "akki"
• PROBLEM 5: "3-D Convex Hull" closed on PROBLEM 6: "Maximum Independent Set" The final problem for this years Threading Challenge is due Nov 20th! Submit your solution TODAY!

PDC09 - Microsoft Professional Developers Conference - November 17 - 19, 2009 at the Los Angeles Convention Center, California

SC09 - The Super Computer Conference - November 14-20, 2009 in Portland, Oregon. The Intel Software and the Intel Academic Community team will be broadcasting live at Supercomputing 09 in Portland Oregon.  We are sponsoring keynotes, talks, and sessions. Our friends at Microsoft will also be attending and presenting at SC09 Steve Teixeira, Microsoft Parallel Development Tools Product Unit Manager is giving talks at SC09.

SC09 Key Notes

• Justin Ratner, CTO Intel - The Rise of the 3D Internet: Advancements in Collaborative and ImmersiveAl Gore
• Al Gore, Building Solutions: Energy, Climate and Computing for a Changing World

Intel Parallel Universe Launched!

On the show today we broadcast live from SC09 and talked with James Reinders about the launch of Intel Parallel Universe. This online tool analyzes your threaded applications to help you tune them. Upload your application, with related files and arguments needed to make it run, and the service returns scaling and concurrency efficiency info to help you get better performance and take better advantage of multi-core systems.

Coming up next on Parallel Programming Talk

The first Tuesday of the month is our Listener Questions show. December 8th is the next one.
If you have a question or idea about the show send it in to ParallelProgrammingTalk@Intel.com

Nov 24 - Mike McCool, Stefanus Du Toit & Anwar Ghuloum on Data Parallism
Dec 1 - Listener Question
Dec 8 - Tom Spyrou of Cadence
Dec 15 -  Best Of 2009 Show
Dec 22 -  Best Of 2009 Show
Dec 29 -  Best Of 2009 Show
Jan 5 -  Best Of 2009 Show
Jan 12 - Kick Off New Year

The Intel® Software Partner Program gives you access to program tools and developer resources that help you create energy-efficient software for maximum battery life. These tools also help you optimize applications for improved user experiences in mobile environments and smoother transitions between online and offline experiences.

Now is the time to optimize. A competition called "Succeed" is enabling developers to win more than new customers with their efforts. By using Intel® Software Development Tools for mobility or any of our other technology focus areas, you could win one of seven co-marketing campaign prizes valued at $5,000 each or 10 second prizes of Intel Software Development Tools valued at ~$600 each.

Entering is easy. Every finished Project Completion Report you submit qualifies you for an entry. The entry form asks you to submit: a) a tagline for an Intel® technology used to optimize your software, and b) a creative idea in 50 words or less for an online marketing campaign to promote your software. Learn more about our Succeed competition—and get in your entry soon. The deadline for entries is December 31, 2009.

Enroll in Intel Software Partner Program today and learn how the program can help you deliver innovative solutions to meet your users' demands. Learn More.

Starting today, developers can test the scaling of their applications to multi-core using the new Intel® Parallel Universe Portal, a cloud-based scaling analysis tool to help with parallel programming.  There is currently no charge for this service; it is available online here on the Intel Software Network at paralleluniverse.intel.com.

To read more of the story, see the article posted today.

Such reports on scaling, especially on larger numbers of cores, can really help when tuning a program for multicore processors. Most of us doing a parallel application today will test it on a few cores but that doesn’t give us the feedback about how our decisions today impact the future. I’m sure Intel would appreciate us all running out and buying systems that are at least eight cores (more is better) – but that isn’t in everyone budget quite yet. And that’s a problem when we are in the thick of designing, testing and tuning an application that we'd like to scale for the future.

Therefore, we have opened the Intel® Parallel Universe Portal with our first cloud-based tuning tool. You’ll find the reports it creates to be useful whether you have Intel Parallel Studio or not. Your program need not be built with Parallel Studio and the reports are readable without Parallel Studio. But owning Parallel Studio has benefits - because you can start with a more optimal program to test (which is a good thing when tuning for scaling) and you’ll be able to download the results of our sixteen hardware thread tests to compare with any testing you are doing in Intel Parallel Studio already. Such side-by-side comparison in the Parallel Studio tool can be enlightening.

Using the portal is a snap, once your code is debugged and ready to run – simply zip the EXE file and any other files needed and upload it. Parallel Universe runs it and presents a report on how it scales when run on one to sixteen hardware threads. The runs are done on a single system with no other applications running on the machine at the same time - thereby giving very pure and interesting reports. The summary report gives a handy overview which is useful for tuning. A more detailed results file can be downloaded and used in Parallel Studio to drill down to specific functions or even specific lines of code.

The most common usage of this testing service will probably on portions of an application rather than entire applications. It is not intended for applications that require user interaction (such as a GUI application), and it is not for testing programs that run more than a few minutes. Instead, you’ll want to have the code you are working on, packaged into some sort of wrapper to drive it, and upload that. Of course, you can upload your entire application – if it can be driven from a command line, runs in less than a few minutes, and doesn’t require user interaction.

Our new portal will be very useful to users with and without Intel Parallel Studio. Of course, for those who have not moved to using Intel Parallel Studio – this might be just what you needed to convince you! You can use the portal free, and you can download a Parallel Studio trial for evaluation from http://intel.com/go/parallel to take for a test spin for a few weeks.

Probably too many details…?
I can tell you more, a.k.a. the fine print, or you might just run off and try it: paralleluniverse.intel.com.

We’ve tested on multiple web broswers: Internet Explorer, Firefox, Safari and Chrome. Parallel Universe is provided through the Intel® Software Network (ISN), so you manage your submissions and resuting reports through your account so they are just for you to see. Signing up for ISN is free and easy, you’ll find a link on the Parallel Universe page to create an account if you don’t have one already.

Applications need to be put into a zip file with all the dependent piece/parts, including configuration files and libraries as it would run under Windows. There’s a text-box for providing the execution command and any arguments for your application.

The Parallel Universe site provides a link to a community forum for exchanging tips, information, suggestions, etc. We welcome your comments and ideas!

Jobs are queued up, reports are archived for later access

When you submit your application, it goes into a queue so that it can be scheduled to run alone on the systems. It gets the whole system to itself so performance testing on your application is done without resources being shared with other applications. The wait-time is usually pretty short and the tool provides a ‘results’ window that tells you its status.

When the analysis is done, you just click a link and your browser displays results about scalability and average concurrency of your application. The system tells you how the application ran on configurations with 1, 2, 4, 8 and 16 hardware threads and it provides specific configuration information about the system. Results are presented in tables (for the numbers-oriented) and line-charts (for the graphically-oriented), which make it pretty easy to see if your application is scaling. It also reports on the average concurrency over the same range of processor configurations, which is the number of threads the application was running, on average, over the time it took to run. If you see it plateauing at six threads on a 16-way system, it may be an indication that performance is being left on the table. In such a case, we might want to do something about it – make scaling adjustments – before shipping your application to customers with such systems.

Still reading? Go try it out…

I hope you give it a try and share your experiences and comments in the Parallel Universe Community Forum!

I'm presently attending the Microsoft PDC 2009 conference and I am today in the Patterns of Parallel Programming workshop.

It appeared that the workshop was being recorded and so I sent an e-mail to some of the PDC 2009 organizers and can confirm that the Patterns of Parallel Programming workshop recording will be available to all attendees.

Richard Ciapala, Ade Miller, Herb Sutter, and Stephen Toub presented an excellent session on where we are with the parallelism today and where the Microsoft platform can take you in the parallel future.