You are here

Feed aggregator

求助!原来在 HCK QFE 006 中通过的测试现在在 QFE 007 和 QFE 008 中失败

MSDN Blogs - Mon, 04/07/2014 - 19:58

我们发现 HCK 2.1 QFE 007 在测试中引入了一些在以前版本的工具包中使用的回归算法。


  • BitLocker Tpm And Recovery Password tests for AOAC devices with Legacy PCRs
  • BitLocker Tpm And Recovery Password tests for AOAC devices with PCR 7
  • BitLocker Tpm+PIN+ USB and Recovery Password tests for NON ARM devices
  • BitLocker Tpm and Recovery Password tests for non-AOAC devices for Legacy PCRs
  • BitLocker Tpm and Recovery password tests for non-AOAC devices with PCR 7
  • Storage Performance CS
  • BDE WLK Test
  • BDE WLK Test - OS Volume Only

我们创建了一组勘误表来解决这些问题,同时还在开发和测试修复工具包。如果您正在尝试使用 HCK 2.1 QFE 007 或 QFE 008 进行提交,并且在这些测试中遇到失败的情况,请使用此表确定相应勘 误表,并将其写在你提交的 readme.doc 文件中:


 HCK Errata: System - Partition Validation in QFE007


 HCK Errata: BitLocker Tpm and Recovery Password tests for non-AOAC devices for Legacy PCRs test fails in QFE007 and QFE008


 HCK Errata: BitLocker Tpm+PIN+ USB and Recovery Password tests for NON ARM devices failing in QFE007 and QFE008


 HCK Errata: Test BitLocker Tpm And Recovery Password tests for AOAC devices with Legacy PCRs failing in HCK 2.1 with QFE007 and QFE008


 HCK Errata: Test BitLocker Tpm And Recovery Password tests for AOAC devices with PCR[7] failing in HCK 2.1 with QFE007 and QFE008


 HCK Errata: Test BitLocker Tpm and Recovery password tests for non- AOAC devices with PCR[7] failing in HCK 2.1 with QFE007 and QFE008


 HCK Errata: Test Storage Performance CS failing in HCK 2.1 with QFE007 and QFE008


 HCK Errata: Test BDE WLK Test failing in HCK 2.1 with QFE007 and QFE008


 HCK Errata: Test BDE WLK Test - OS Volume Only failing in HCK 2.1 with QFE007 and QFE008

April Updates to the Azure Toolkit for Eclipse– Azure SDK 2.3, Tomcat 8, New Zulu versions, and more!

MSDN Blogs - Mon, 04/07/2014 - 19:23

Microsoft Open Technologies, Inc., has now published the Azure Toolkit for Eclipse (by Microsoft Open Technologies) - April 2014 release. This update accompanies the release of Azure SDK 2.3, which is a pre-requisite. You will be offered the option to install it automatically when you create the first project after installing the toolkit.

This release includes multiple enhancements since the February 2014 release, including support for new versions of application servers (Tomcat 8), JDKs (Azul Zulu v1.7 update 51 and v1.6 update 47), support for larger, bigger memory Azure instances (A8 and A9), improved handling of SSL and HTTPS, and in-place upgrading of deployed applications.

Have a look at the Blog post for more details.

Goodbye Windows XP - Hello Windows 8.1 Update

MSDN Blogs - Mon, 04/07/2014 - 19:00

Today heralds the end of an era. After 12 years, support for Microsoft Windows XP will end on today, 8th April 2014 (in around 14 hours time after this article is published).

This comes as no surprise as the date for the end of Windows XP extended support was announced about 6 years ago.

Opinion: While Windows XP was a great operating system when it was released, it is now significantly out of date. Microsoft have released Windows Vista, Windows 7 and Windows 8 since. I have heard of situations where people say that they are looking at competitive solutions to Windows and Office because Microsoft is behind the times and not embracing new technologies. When you look closer, you find that they are comparing Windows XP and Office 2003 or Office 2007 (7-10 year old software) with the latest technology from our competitors. They should be comparing against Windows 8.1 and Office 365 or Office 2013 to get the big picture of how the Microsoft devices and services ecosystem really works.

To help those still using Windows XP. I wanted to bring together a number of resources from Microsoft websites and blog articles to help explain what the end of support means for both consumer and enterprise customers and what options are available moving forward:


Today also brings the release of the Windows 8.1 Update. The update to the Windows 8.1 release. This update includes a number of features designed to make using the Modern UI and Start Page of Windows 8 easier for users on non-touch (mouse and keyboard only) systems.

Check out the video and blog post below:  

Introducing the Windows 8.1 Update (Direct Link)

(Please visit the site to view this video)


For more information on what Windows 8.1 Update offers, have a look at the following post from the Windows Experience Blog:


Hope you find this information useful. 


The JIT finally proposed. JIT and SIMD are getting married.

MSDN Blogs - Mon, 04/07/2014 - 18:37

Processor speed no longer follows Moore’s law. So in order to optimize the performance of your applications, it’s increasingly important to embrace parallelization. Or, as Herb Sutter phrased it, the free lunch is over.

You may think that task-based programming or offloading work to threads is already the answer. While multi-threading is certainly a critical part, it’s important to realize that it’s still important to optimize the code that runs on each core. SIMD is a technology that employs data parallelization at the CPU level. Multi-threading and SIMD complement each other: multi-threading allows parallelizing work over multiple cores while SIMD allows parallelizing work within a single core.

Today we’re happy to announce a new preview of RyuJIT that provides SIMD functionality. The SIMD APIs are exposed via a new NuGet package, Microsoft.Bcl.Simd, which is also released as a preview.

Here is an example on how you would use it:

// Initalize some vectors

Vector<float> values = GetValues();
Vector<float> increment = GetIncrement();

// The next line will leverage SIMD to perform the
// addition of multiple elements in parallel:

Vector<float> result = values + increment; What’s SIMD and why do I care?

SIMD is by far the most popular code gen request and still a fairly popular request overall (~2,000 votes on user voice):

It’s so popular because, for certain kinds of apps, SIMD offers a profound speed-up. For example, the performance of rendering Mandelbrot can be improved a lot by using SIMD: it improves by a factor of 2-3 (using SSE2-capable hardware) up to a factor of 4-5 (using AVX-capable hardware).

Introduction to SIMD

SIMD stands for “single instruction, multiple data”. It’s a set of processor instructions that operate over vectors instead of scalars. This allows mathematical operations to execute over a set of values in parallel.

At a high-level, SIMD enables data parallelization at the CPU level. For example, imagine you need to increment a set of floating point numbers by a given value. Normally, you’d write a for loop to perform this operation sequentially:

float[] values = GetValues();
float increment = GetIncrement();

// Perform increment operation as manual loop:
for (int i = 0; i < values.Length; i++)
    values[i] += increment;

SIMD allows adding multiple values simultaneously by using CPU specific instructions. This is often exposed as a vector operation:

Vector<float> values = GetValues();
Vector<float> increment = GetIncrement();

// Perform addition as a vector operation:
Vector<float> result = values + increment;

It’s interesting to note that there isn’t a single SIMD specification. Rather, each processor has a specific implementation of SIMD. They differ by the number of elements that can be operated on as well as by the set of available operations. The most commonly available implementation of SIMD on Intel/AMD hardware is SSE2.

Here is a simplified model of how SIMD is exposed at the CPU level:

  1. There are SIMD-specific CPU registers. They have a fixed size. For SSE2, the size is 128 bit.

  2. The processor has SIMD-specific instructions, specific to the operand size. As far as the processor is concerned, a SIMD value is just a bunch of bits. However, a developer wants to treat those bits as a vector of, say, 32-bit integer values. For this purpose, the processor has instructions that are specific to the operation, e.g. addition, and the operand type, e.g. 32-bit integers.

An area where SIMD operations are very useful is graphics and gaming as:

  • These apps are very computation-intensive.
  • Most of the data structures are already represented as vectors.

However, SIMD is applicable to any application type that performs numerical operations on a large set of values; this also includes scientific computing and finance.

Designing SIMD for .NET

Most .NET developers don’t have to write CPU-specific code. Instead, the CLR abstracts the hardware by providing a virtual machine that translates your code into machine instructions, either at runtime (JIT) or at install time (NGEN). By leaving the code generation to the CLR, you can share the same MSIL between machines with different processors without having to give up on CPU-specific optimizations.

This separation is what enables a library ecosystem because it tremendously simplifies code sharing. We believe the library ecosystem is a key part of why .NET is such a productive environment.

In order to keep this separation, we needed to come up with a programming model for SIMD that allows you to express vector operations without tying you to a specific processor implementation, such as SSE2. We came up with a model that provides two categories of vector types:

Both categories of types are what we call JIT intrinsics. That means the JIT knows about these types and treats them specially when emitting machine code. However, all types are also designed to work perfectly in cases where the hardware doesn’t support SIMD (unlikely today) or the application doesn’t use this new version of RyuJIT.

Our goal is to ensure the performance in those cases is roughly identical to sequentially written code. Unfortunately, in this preview we aren’t there yet.

Vectors with a fixed size

Let’s talk about the fixed-size vectors first. There are many apps that already define their own vector types, especially graphic intense applications, such as games or a ray tracer. In most cases these apps use single-precision floating point values.

The key aspect is that those vectors have a specific number of elements, usually two, three or four. The two-element vectors are often used to represent points or similar entities, such as complex numbers. Vectors with three and four elements are typically used for 3D (the 4th element is used to make the math work). The bottom line is that those domains require vectors with a specific number of elements.

To get a sense how these types look, look at the simplified shape of Vector3f:

public struct Vector3f
    public Vector3f(float value);
    public Vector3f(float x, float y, float z);
    public float X { get; }
    public float Y { get; }
    public float Z { get; }
    public static bool operator ==(Vector3f left, Vector3f right);
    public static bool operator !=(Vector3f left, Vector3f right);
    // With SIMD, these element wise operations are done in parallel:
    public static Vector3f operator +(Vector3f left, Vector3f right);
    public static Vector3f operator -(Vector3f left, Vector3f right);
    public static Vector3f operator -(Vector3f value);
    public static Vector3f operator *(Vector3f left, Vector3f right);
    public static Vector3f operator *(Vector3f left, float right);
    public static Vector3f operator *(float left, Vector3f right);
    public static Vector3f operator /(Vector3f left, Vector3f right);

I’d like to highlight the following aspects:

  • We’ve designed the fixed size vectors so that they can easily replace the ones defined in apps.
  • For performance reasons, we’ve defined those types as immutable value types.
  • The idea is that after replacing your vector with our vector, your app behaves the same, except that it runs faster. For more details, have a look at our Ray Tracer sample application.
Vectors with a hardware dependent size

While the fixed size vector types are convenient to use, their maximum degree of parallelization is limited by the number of components. For example, an application that uses Vector2f can get a speed-up of at most a factor of two – even if the hardware would be capable of performing operations on eight elements at a time.

In order for an application to scale with the hardware capabilities, the developer has to vectorize the algorithm. Vectorizing an algorithm means that the developer needs to break the input into a set of vectors whose size is hardware-dependent. On a machine with SSE2, this means the app could operate over vectors of four 32-bit floating point values. On a machine with AVX, the same app could operate over vectors with eight 32-bit floating point values.

To get a sense for the differences, here is a simplified version of the shape of Vector<T>:

public struct Vector<T> where T : struct {
    public Vector(T value);
    public Vector(T[] values);
    public Vector(T[] values, int index);
    public static int Length { get; }
    public T this[int index] { get; }
    public static bool operator ==(Vector<T> left, Vector<T> right);
    public static bool operator !=(Vector<T> left, Vector<T> right);
    // With SIMD, these element wise operations are done in parallel:
    public static Vector<T> operator +(Vector<T> left, Vector<T> right);
    public static Vector<T> operator &(Vector<T> left, Vector<T> right);
    public static Vector<T> operator |(Vector<T> left, Vector<T> right);
    public static Vector<T> operator /(Vector<T> left, Vector<T> right);
    public static Vector<T> operator ^(Vector<T> left, Vector<T> right);
    public static Vector<T> operator *(Vector<T> left, Vector<T> right);
    public static Vector<T> operator *(Vector<T> left, T right);
    public static Vector<T> operator *(T left, Vector<T> right);
    public static Vector<T> operator ~(Vector<T> value);
    public static Vector<T> operator -(Vector<T> left, Vector<T> right);
    public static Vector<T> operator -(Vector<T> value);

Key aspects of this type include the following:

  • It’s generic. To increase flexibility and avoid combinatorial explosion of types, we’ve defined the hardware-dependent vector as a generic type, Vector<T>. For practical reasons, T can only be a primitive numeric type. In this preview, we only support int, long, float and double. The final version will also include support for all other integral numeric types, including their unsigned counterparts.

  • The length is static. Since the length is hardware -dependent but fixed, the length is exposed via a static Length property. The value is defined as sizeof(SIMD-register) / sizeof(T). In other words, two vectors Vector<T1> and Vector<T2> have the same length if T1 and T2 have the same size. This allows us to correlate elements in vectors of different element types, which is a very useful property in vectorized code.

Vectorization is a complicated topic and, as such, it’s well beyond the scope of this blog post. Nonetheless, let me give you a high-level overview of what this would mean for a specific app. Let’s look at a Mandelbrot renderer. Conceptually, Mandelbrot works over complex numbers which can be represented as vectors with two elements. Based on a mathematical algorithm, these complex numbers are color-coded and rendered as a single point in the resulting picture.

In the naïve usage of SIMD, one would vectorize the algorithm by representing the complex numbers as a Vector2f. A more sophisticated algorithm would vectorize over the points to render (which is unbounded) instead of the dimension (which is fixed). One way to do it is to present the real and imaginary components as vectors. In other words, one would vectorize the same component over multiple points.

For more details, have a look at our Mandelbrot sample. In particular, compare the scalar version to the vectorized version.

Using the SIMD preview

In this preview we provide the following two pieces:

  1. A new release of RyuJIT that provides SIMD support
  2. A new NuGet library that exposes the SIMD support

The NuGet library was explicitly designed to work without SIMD support provided by the hardware/JIT. In that case, all methods and operations are implemented as pure IL. However, you obviously only get the best performance when using this library in conjunction with the new release of RyuJIT.

In order to use SIMD, you need to perform the following steps:

  1. Download and install the latest preview of RyuJIT from

  2. Set some environment variables to enable the new JIT and SIMD for your process. The easiest way to do this is by creating a batch file that starts your application:

    @echo off
    set COMPLUS_AltJit=*
    set COMPLUS_FeatureSIMD=1
    start myapp.exe
  3. Add a reference to the Microsoft.Bcl.Simd NuGet package. You can do this by right clicking your project and selecting Manage NuGet References. In the following dialog make sure you select the tab named Online. You also need to select Include Prelease in drop down at the top. Then use the textbox in the top right corner to search for Microsoft.Bcl.Simd. Click Install.

Since this a preview, there are certain limitations you may want to be aware of:

  • SIMD is only enabled for 64-bit processes. So make sure your app either is targeting x64 directly or is compiled as Any CPU and not marked as 32-bit preferred.

  • The Vector type only supports int, long, float and double. Instantiating Vector<T> with any other type will cause a type load exception.

  • SIMD is only taking advantage of SSE2 hardware, currently. Due to some implementation restrictions, the RyuJIT CTP cannot automatically switch the size of the type based on local hardware capability. Full AVX support should arrive with a release of the .NET runtime that includes RyuJIT. We have prototyped this, but it just doesn’t work with our CTP deployment model.


We’ve released a preview that brings the power of SIMD to the world of managed code. The programming model is exposed via a set of vector types, made available via the new Microsoft.Bcl.Simd NuGet package. The processor support for the operations is provided with the new preview of RyuJIT.

We’d love to get your feedback on both pieces. How do you like the programming model? What’s missing? How does the performance look like for your app? Please use the comments for providing feedback or send us mail at ryujit(at)

Interview with a Windows Phone Development Guru - MCosmin

MSDN Blogs - Mon, 04/07/2014 - 18:30

This interview is with...



Here are some of his stats:

  • 4 TechNet Guru Gold Medals
  • 1,872 Recognition Points

Here are MCosmin's winning articles:


Who are you, where are you, and what do you do? What are your specialty technologies?

Hello everyone, my name is Mihai Cosmin-Constantin, from Romania, and at the time of this writing, living in the capital city of Bucharest. I am 21 years old (soon to be 22), currently attending the final year courses of Automatic Control, Computer Science and System Engineering at Polytechnic University of Bucharest.

I started developing for Windows Phone, the 7.1 SDK almost 3 years ago, as a hobby in my spare time, after attending a Nokia conference in Bucharest, describing the new features of Windows Phone 7.5. Since then, I began learning about Microsoft technologies, such as .NET Framework and Windows Runtime, developing simple apps for my own personal use.

Right now, I am actually working on several projects. Probably the most important one is a health-care program used to diagnose victims of remote access in difficult to access areas, using infrastructure powered by windows 8 and windows phone 8, my part in the project is developing “data mining” apps that gather data about the state of individuals using a wide variety of sensors.

There are also various projects already published on the windows phone store, the most troublesome one being an experimental media player project (which I hope will see better days with windows phone 8.1 SDK). Some of the articles I published on TechNet wiki are directly related to these endeavors.

This photo is taken at a conference about eHealth where my teacher (Mr. Ciprian Lupu, in the middle) Cornel Eugen (on the right), and I presented a health program:


What is TechNet Wiki for? Who is it for?

TechNet wiki is a great concept and quite an ambitious endeavor to unite all things technical about Microsoft products under one roof. It is a great place to find solutions for your problems, even if you are not a developer. And the best thing is that everyone can contribute their great experiences to help others.


What do you do with TechNet Wiki, and how does that fit into the rest of your job?

For the most part, I simply write articles for the Guru of the Month contest. Considering that most of my apps are either experimental or not for public eyes, the TechNet Wiki offers me a way of displaying my skills.

Here I am with my brother:


What is it about TechNet Wiki that interests you?

The high quality of the articles published on this website and the fact that once you contributed your work, others can improve upon your initial work, resulting in a great knowledge base for everyone to use when in trouble.  


On what Wiki articles do you spend most of your time?

I lurk in the Windows Phone and Windows Store apps section at the moment, although I intend to move out to Visual C# related topics soon enough.

My father and I are at sea side in Constanta, Romania:


What are your favourite Wiki articles you’ve contributed?

My favourite article is also the one I worked on the most, where I explain how to play FLAC files on windows phone using the Media Stream Source API. Figuring out how to enable flac playback on Windows Phones took quite a lot of time for me, and I am pleased to see others found my research useful. (


Do you have any tips for new Wiki authors?

I think the most important thing to understand for new Wiki authors is that they need to provide great and useful content, and more importantly, original content. If they have a nice idea that nobody mentioned so far on the Wiki, they should take the chance and publish their idea, so that others can build upon that. This is basically a win-win situation: the community gains something new, while the author wins recognition from a professional community.

My mom and I are at a park at sea side in Constanta:




Thank you, Mihai, for all your contributions! Your innovative articles have been a great opportunity for us to learn with you!

   - Ninja Ed


How to find Team Foundation Server(TFS) 2012 GUID Info

MSDN Blogs - Mon, 04/07/2014 - 18:29
Deepak Kumar Mishra, Team Foundation Server, EMEA Engineer brings to us his experience on one of the issues that he came across few days back , where customer landed to an upgrade issue in Production server while upgrading from TFS 2012 UPDATE 1 TO tfs 2012 Update 4. So User had to go for a roll back so that TFS downtime did not impact the BAU process. Then the user planned for doing a test upgrade and test if everything goes fine on the Test server. And User needed Microsoft's assistance in this...(read more)

Using Azure Service Bus to Build Pub/Sub Application (Part-1)

MSDN Blogs - Mon, 04/07/2014 - 18:25

I have a project that requires building an online system with large data flow to satisfy two groups of users. One group of users are data publishers, They could be retail customers using web browser to call our online services, or partners who call our services through web Api service, or client application. The other group of users are receiving and consuming the data sent from the first group of users. The system can be designed by using "Publish-Subscribe" software pattern ( In Azure cloud, using Service Bus as messaging framework would be the best fit for the described business scenario.  But, we need to address a list of technical questions, in order to come up with a high level design.

1. How do we enable anonymous users to send data to our system?

There are basically two ways to access Azure Service Bus, RESTful API or SBMP (Service Bus Messaging Protocol), both of which require secured connection (by connection string, or certificate to create token). Letting users to access our Service Bus directly doesn't sound a realistic solution.

2. How to distribute data interface to geographical locations to serve users at anywhere in US?

Azure Service Bus are configured by data center location, the same as Azure WebRole instances. It is important to assemble the two components together by location in order to follow principle of the lowest network latency and the highest service resilience. 


Here is a high level architecture design.

Since most users are on internet, web interface is designed to accept data published by users. We implement a web Api service that exposes data publishing "endpoint". It is by HTTP connection with SSL cert authentication to guarantee a secure server access to users. However, asking every user to be authorized before he/she could send data is a little bit challenging here.

Considering that users could be from anywhere in US, the web Api service is deployed to two data centers (i.e. US west, US east). To accommodate geo-distributed design requirement, we've prepared for two Service Buses, one in each data center (USW and USE).

All the WebRole instances have connections to the Service Bus instances (SBMP), but their primary data transferring target is the Service Bus instance in local data center. This means data received by webRole instance in US west data center is sent to Service Bus instance in the same US west data center. However, in case the "send" action fails due to local Service Bus unavailability issues, the same data is resent to the service bus in remote data center (US west data center in this example.) This will minimize risk of possible data loss during the transfer process.

All the published data is organized by topic name. We manage a list of TopicClients, each of which "maps" to a specific topic name on a specific Service Bus instance. Therefore, we can use SubscriptionClient to gather all data from the other end of two Service Bus instances, and filter data by topic name.

I will continue to discuss on this topic in the next post. Please stay tuned.




Install the VM Agent on an existing Azure VM

MSDN Blogs - Mon, 04/07/2014 - 16:22

The MSI package to install the VM Agent on an existing Azure VM is now available for download:

After you RDP to the VM and install the MSI (same as you would any other MSI package), use the April 2014 v0.8.0 or later Azure PowerShell release to update the VM property to indicate the agent is installed.

$vm = Get-AzureVM –ServiceName <cloud service name> –Name <VM name>
$vm.VM.ProvisionGuestAgent = $true
Update-AzureVM –Name <VM name> –VM $vm.VM –ServiceName <cloud service name>

Now if you run Get-AzureVM again, the GuestAgentStatus property should be populated instead of blank:

Get-AzureVM –ServiceName <cloud service name> –Name <VM name>


Note the steps to update the VM property are also on the Manage Extensions MSDN page, but the download link to the MSI is incorrect on that page. The correct download link is the one referenced above. We expect to have the link on the MSDN page updated shortly.


Subscribe to Randy Riness @ SPSCC aggregator
Drupal 7 Appliance - Powered by TurnKey Linux