Some time ago I was interviewed (via email) by El Financiero, a weekly business-oriented newspaper from Costa Rica, regarding 64–bit technologies. A small quote from the interview was published a couple of weeks ago, along with some information I gave them on the advantages of moving to 64–bits.
The technical journalist from the newspaper did an article on how the Costa Rican Central Bank, BCCR, is moving their payments system (SINPE) from 32–bit to 64–bit servers, and the benefits they are getting from the move. These benefits include enhanced speed and database performance, given the large memory capacity of the new architecture. This is a fairly large system that handles over 3 million financial transactions per month.
ArtinSoft had some involvement in moving this system from Visual Basic 6.0 to Visual Basic .NET some time ago, in the dawn of the .NET era. There is even a published case study on the system – you can find it here.
Their plan currently is to slowly move all their systems to 64–bit over a period of 2 years.
You can check out the article here: BCCR ajustó tecnologías (you may need to be registered with the site).
Next month we’ll be at the last planned HP Integrity Developer Workshop, in East Rutherford, NJ, between June 12-14. We’ll be in charge of the Windows 64–bit track.
This is the last workshop planned for this year, so make sure you take this opportunity to get hands-on training with HP’s Integrity Servers using Dual-core Itanium CPUs. You can choose to receive training in either Windows, Linux, HP/UX or OpenVMS, and get help with your ports to the Itanium platform. Plus you get to take back home the server you worked on! Check out the benefits from the class (from the Workshop Overview):
- your dual-core Itanium-based application porting efforts well underway or in many cases, completed.
- The HP Integrity rx2620 server that you used in the classroom sent directly to you from the workshop for your continued porting and testing efforts.
- free software development tools
- membership in HP's Developer & Solution Partner Program that allows you to take advantage of GTM and lead generation programs once your port is completed.
Make sure you reserve your spot for the workshop!
There’s going to be a new
Some of you may recall that on some events, we got an error message on Intel Thread Checker during the Multicore lab. No matter what we did, even if we solved all the concurrency issues related to our code, the Thread Checker would always log this message:
Write -> Read data-race Memory read at [PrimesInstrumented.exe, 0x2468] conflicts with a prior memory write at [PrimesInstrumented.exe, 0x16816] (flow dependence)
During the labs, we have said that we've been working out the solution with the Intel support people - and now we have an answer!!The thing is that you can work with Thread Checker in two ways:
- Use compiler based instrumentation. With this, you basically need to add the /Qtcheck flag to the compiler command line to instrument the binary. Once it is instrumented and you run it, it will create a file called "Threadchecker.thr", that you can then load in the VTune Thread Checker. To do this, you need to use the following command lines: (using the primes example from the lab)
icl /c /Zi primes.cpp /Qopenmp /Qtcheck /Od
link primes.obj /out:PrimesInstrumented.exe /fixed:no /DEBUG
- Use Thread Checker to intrument the application. In this scenario, you don't intrument the binary at compile time, but have Thread Checker intrument it when running the application. For this, you need to build the application with the following command lines:
icl /c /Zi primes.cpp /Qopenmp /MD /Od
link primes.obj /out:PrimesInstrumented.exe /fixed:no /DEBUG
And then load it in Thread Checker.
The error we were doing on the lab is that we were using both compiler and "Thread Checker" instrumentation, and that caused Thread Checker to report conflicts that are outside of the program and in the runtime libraries. Now, using either option (BUT not both at the same time) the strange error is gone!
Thanks to Vasanth Tovinkere at Intel who really helped us out with this problem!!
BTW, this is repeating an old blog post I did for the 64–bit Advantage Blog. The post was deleted for some reason. Since I consider this information to be important, I am re-posting it here.
You can create C++ application in Visual Studio that use OpenMP. When you run an application created with OpenMP and VS.NET, however, you may get this annoying error message: “This application has failed to start because vcompd.dll was not found. Re-installing the application may fix this problem.”:
When we tried this, we were puzzled by this error message, especially since it works with the Intel Compiler flawlessly. Well, it turns out that you need to include omp.h in your files ALWAYS when you use OpenMP from Visual Studio. This is not required on other compilers if you’re only using the OpenMP pragmas, but it is an issue with Visual Studio.
Thanks to Kang Su for pointing this out in his blog – I was going crazy trying to figure out what was wrong.
Also remember to enable OpenMP support in the C++ Project properties. This setting is in Configuration Properties->C/C++->Language->OpenMP Support.
OpenMP is very easy-to use API that you can use to very rapidly add multi-threading to your C/C++ applications. OpenMP allows you to parallelize the execution of a region of code by just adding a few pragmas to the code. For example, take this code:
for(int i = 0;i<=100;i++){
a[i] = a[i]*10;
...
}
The code above performs a for loop sequentially. Since each iteration could be executed independently, we can easily add multi-threading to the application by adding these simple pragmas:
#pragma omp parallel for
for(int i = 0;i<=100;i++){
a[i] = a[i]*10;
...
}
The omp pragmas tell the compiler to generate code to parallelize the execution of the for loop. That means that if you run this code on a 4 core machine, it will create 4 threads, and each one will execute 25 iterations of the loop. Just by adding those pragmas, you now have a multi-threaded application that takes advantage of multi-core systems.
Yes, it's that simple.
Last I week I posted about the Itanium 2 9000 Series being launched with hardware virtualization support (what was formerly known as Silvervale). I also mentioned that neither Windows 2003, Virtual Server, nor Longhorn will support virtualization on this platform. That much is true from Microsoft’s perspective, but HP is indeed planning to support Windows 2003 Server through its Virtual Server Environment.
The Virtual Server Environment has been available for a while, and also has an enterprise-class management tool in the HP Integrity Essentials Virtualization Manager. This is currently available for HP-UX, but will also be available for Linux and Windows in the near future. The Virtualization Manager has some interesting features, and is also integrated with HP’s Serviceguard product. From last month’s press release:
... For example, customers can use the capability to automatically allocate additional server capacity to financial applications during the month-end close.
For customers that are concerned about the availability of their mission-critical UNIX® environments when they consolidate using virtualization, HP has further integrated HP Serviceguard for HP-UX 11i with HP Integrity Virtual Machines. Available now with the latest release of HP Serviceguard, this functionality helps guard against failure by automatically moving the virtual machines between servers in a VSE. HP Integrity Virtual Machines also now enables easy manual migration of virtual machines, accelerating application qualification and deployment....
Keep in mind that HP also offer Node Partitions (nPars) and Virtual Partitions (vPars) options on the high-end Integrity and 9000 lines of servers, with Instant Capacity on Demand (iCOD) capabilities. Depending on your requirements, these may be even better options than virtual machines pure virtual machines.
This is a post from several months ago that I made on the 64–bit Advantage blog. Since now we’re working with virtualization (at the time it was only an interest of mine), I think it is worth it to re-post it here:
I wanted to make a brief mention of the Virtualization Technology that is being introduced in the latest generation of Intel CPUs (known as VT-x). This technology was formerly known as "Vanderpool", and it is already available on some Pentium 4, Pentium D, Xeon and Core Duo CPUs. Later this year it will also be available on the next generation Itanium CPUs, using a technology known as "Silvervale".
I was talking with a coworker the other day about this technology, and our main question was "What is it exactly that it does? What advantage would it have over traditional software virtualization?" Well, to answer these two questions:
On a virtualization environment, there's the Virtual Machine Monitor (VMM), which handles the processor and physical resources of the machine, and the Guest Software, which operate inside a Virtual Machine handled by the VMM. VT-x introduces 10 new intructions to the architecture for facilitating the tasks of the VMM. Some of them, such as VMLAUNCH and VMRESUME, allow the VMM to start/enter running VMs, or VMON/VMOFF, turns the Virtualization functionality on and off.
The main reasons for using VT-x over software virtualization are speed and reliability. With hardware support, you are pretty much creating the equivalent of a hardware partition for the Guest Software, which improves both the performance and the robustness of the VM - and this is vital for consolidated server environments, one of the areas where VT-x is expected to be heavily used.
Now, one thing- why mention Intel's VT-x on this site? Well, one of the strenghts of 64-bit computing is that with more resources available on a single box, it is easier to to consolidate servers. With the new support for virtualization on the CPUs, you can use Virtual Machines for consolidation, so each software server has its own isolated environment without sacrificing performance.
More information here.