BUILD is going to go down like this (my guess)...

Take Rx C++ AMP WPF and the age of MFC.... It will be a WPF++ for C++ and C# and VB in one box.  It will be very big.  WIN32 will start its long slow end of life, yeilding to a faster smaller codebase.  Think modular windows, don't need win32 compatability it don't load, or may not even be installed on an ARM tablet.

TOTAL can be equal to 1 to 64

Try 9 threads on an 8 core machine, seven run at the same speed, and two run at one-half

Try 4 threads then 5 threads.... the scaling is exactly linear right from 1 to 8

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Module Module12
    Private TOTAL As Integer = 8 - 1   'array size = number of threads starting a zero (ex. 8-1 = 8threads)
    Private ClassThreadHolders(TOTAL) As LoopThread 'array of classes
    Private ThreadArray(TOTAL) As Thread      'array of threads
    Private TotalAccumIncs As Long
    Private AccumIncs As Integer

    <MTAThread()>
    Sub Main()
        Dim n As Integer = 0                  'local loop var used in fors
        Dim ThreadPrintLoop As New Thread(AddressOf PrintLoop)

        Console.WriteLine("Building threads...")
        For n = 0 To TOTAL                                      'for each thread
            ClassThreadHolders(n) = New LoopThread                            'assign the class
            ThreadArray(n) = New Thread(AddressOf ClassThreadHolders(n).ActualThread) 'assign the pointer to the thread function
        Next

        Console.WriteLine("starting threads...")
        For n = 0 To TOTAL          'for each thread
            ThreadArray(n).Start()          'start the thread
        Next

        Console.WriteLine("Starting Printloop...")
        ThreadPrintLoop.Start()                'start printing thread

        Console.WriteLine("Waiting for keypress...")
        Console.ReadKey()                       'wait for key
        End                                     'orderly shutdown
    End Sub

    Private Sub PrintLoop()    'thread to print data on
        Do                      'infinite loop of thread
            Thread.Sleep(1000)    'sleep 1000 = 1 sec delay
            For j As Integer = 0 To TOTAL      'for each thread
                ClassThreadHolders(j).Grab()    'force the grab
            Next
            TotalAccumIncs = 0

            Console.Clear()
            For j As Integer = 0 To TOTAL
                AccumIncs = ClassThreadHolders(j).GetGrabbed
                TotalAccumIncs += AccumIncs
                Console.Write(Format(AccumIncs, "000,000,000,000     "))
            Next
            Console.Write(vbCrLf + Format(TotalAccumIncs, "000,000,000,000     "))
        Loop
    End Sub

    Public Class LoopThread         'need a class to have a pointer to a function that can be arrayed
        Private GrabbedInc As Integer
        Private Inc As Integer = 1    'class var must be fully declared
        Private GrabFlag As Boolean
        Private num As Double = 10
        Private num2 As Double = 5

        Public Sub ActualThread()         'sub on the thread
            Do                              'infinite loop of thread
                If GrabFlag = True Then
                    GrabFlag = False
                    GrabbedInc = Inc
                    Inc = 0
                End If
                'num = num * num2 / 50
                Inc += 1
            Loop
        End Sub

        Sub Grab()
            GrabFlag = True
        End Sub

        Public ReadOnly Property GetGrabbed() As Integer
            Get
                Return GrabbedInc
            End Get
        End Property

    End Class

End Module

Looking forward we will see any managed apps written today, should run on ARM unchanged including the XNA games. With the ARM product feature Jazelle should be ported to be the CLR accellerator, now that would be big plus and certainly along the lines of ARM's type of answers to problems. 

Looking back at native x86 programs running on ARM is unlikely to be a in the box Microsoft product.  Although the many DSP and GPU type products typically bundled in the SOC could make the x86 emulation/translation viable.

Well, WPF is far more like learning the MFC libraries then the pure fun of VB past.  That said, the leaning curve is hard.  Big difference is seen when using Blend however.  It makes the monster of WPF and the XAML all go away. 

The XAML is nearly unlearnable to folks like me who refuse to use a product based on route memory.  The is no feeback or help in VS2010 to know what should go where and what it's scope of effects may be.  Clearly we are supposed to by Blend to make any "modern" faced apps.

Flash 9.3 on supported h264 as it's primary format, a recent survey of sites, real ones people use averyday with flash with 90% h264 through flash...  H264 is a done deal as the standard and will only expand because of features and performance on our still very narrow internet bandwidth.

intelman said:

QuickC said:

*snip*

Pretty sure Windows 7 can distinguish HT cores from real cores. Perhaps that is why 4 are unused.

http://www.tomshardware.com/news/windows-hyperthreading-intel-nehalem-atom,7831.html

WIn 7 is surely tuned for Hyper threading, there is no real and hyper cores however.  Each cpu has two threads of code being feed it.  The cpu then looks for stalls, memory read, FPU process, or and answer from another cpu, when it finds a stall it switches to the other thread of code to keep the cpu 100% filled with instructions.

Keep in mind on a 3ghz machine, reading a memory location that isnt in the cpu cache could take 20-100 cycles of the cpu, if the memory has been written to virtual memory it could take 1000-10000 cycles before it can get back to work.

Also, before win7, each spoftware thread was tightly coupled to a particula core, that coupling can be loose between to hyper cores.

Doctor Who said:

Addendum: This is taking so long that I'm getting message windows from WIndows Easy Transfer that say, "Attempting to reconnect", and then they go away and it starts again, and then the "Attempting to reconnect" window pops back up, etc.

 

Use the transfer wizard to a local hard disk not directly to the new computer. 

AS far as whats going on...  It's going through every reg key and file and comparing them to a save list database then moving them into one big file (zipped).

Vista was and Is since SP1 faster the XP on anything but the "benchmarks".  It multitasks smoother for people using heavy amounts of computing, say a few copies of LINUX.  Benchmarks are nearly useless at this point in the PC evalution. 

Win7 handles 8 cpus like it was made for it, well I guess it was, and will never be unresponsive to the user, that is my experience with XP and WIN7 on very heavy loads to the tune of 64 threads and all 8 cores at 100%, still baby smooth, XP will not be smooth if you use more the 80% cpu, it just wasn't written to handle it!

A second note, I'm not sure what program you were using to test the cpu, but if it was a .net program using the thread pool, it will only ever get 50% of the total load at that time, due to thread fairness in win7 with .net 4.