Race Driver GRID 2008
Race Driver: Grid (stylized as Racedriver GRID, in the Americas, known simply as GRID) is the most recent addition to the TOCA Touring Car series.
Doom 3: Resurrection of Evil Game Guide
Doom 3: Resurrection of Evil is a first-person shooter video game developed by Nerve Software and id Software. It was released for the PC on April 3, 2005, as an expansion pack for Doom 3 and on October 5, 2005, for the Xbox video game console.
Games PC; Art Of Murder: Deadly Secrets Final Portable
New Yk city was beaten with a series of murders and the death toll mounting. FBI Agent Nicole Bonnet F to find an advantage it has become impossible as it seems that the victims are all antiques and collects and unrelated to the other.
Air Conflicts: Secret Wars 2011
Air Conflicts: Secret Wars is an arcade flight simulator set for World War II scenario +. During his seven campaigns, the player must fly and fight with more than 48 missions.
Tips for Travel Packing
When planning to take a trip, the hard task is packing all the things that you really need and leaving the things that you want. To make your travel packing a whole lot easier, here are a few helpful tips that should help you:
Kamis, 29 Maret 2012
Seven Ways to Stop Piracy WITHOUT DRM
Selasa, 28 Juni 2011
Smartphone Security

Hang on Tight
Currently, the number one threat to smartphone users is having the device end up in the wrong hands, through theft or loss. Your first line of defense, therefore, is constant vigilance regarding your smartphone’s whereabouts.
Use a Password and Encryption
Should your phone get lost or stolen, a good first layer of protection is a password, an option many phone users neglect. Choose the strongest password option available—a passphrase, for instance, rather than a four-digit code or swipe pattern. Encryption options vary among mobile OSes, but when possible, you should encrypt your storage card as well as your device memory. Back Up Your Data Just as with a PC, backing up your smartphone is important. Regularly synching the device to a linked computer will do the trick. It’s insurance against the loss of your phone, corruption of your OS, or any other event that jeopardizes your data.
Don’t Store Sensitive Data
The surest way to guard your sensitive data is to keep it off your smartphone altogether. Minimize the number and/or days of emails you store on your phone, or better yet, save email and attachments to a server. Make it a habit to regularly move or delete anything you wouldn’t want to share with strangers.
Practice App Awareness
An abundance of apps is both a blessing and a curse for smartphones—there is no way every app that makes it to market can be thoroughly vetted for 100 percent fail-safe security. By selecting reputable apps, backed by favorable user reviews, from a trusted source, you can diminish the risks. Avoid apps with scant reviews or that have only recently been uploaded. Also be cautious when granting an app permissions; consider the app’s function and what it might reasonably need access to.
Keep Software/Firmware Updated
Make sure you are running the latest versions of your apps, OS, and phone manufacturer software and fi rmware. This will ensure that any security holes are patched and your device is less vulnerable to hacks.
Disable Bluetooth and Wi-Fi When Not in Use
Unsecured wireless networks can be used by hackers to either attack your phone or steal information from it. You can protect yourself by keeping Wi-Fi and Bluetooth off when you don’t need them. When wireless is needed, stick to known Wi-Fi networks using WPA2 and beware of public networks, which are sometimes set up by crooks to snare people’s data.
When using Bluetooth, make sure it’s in non-discoverable mode to avoid hacks like “Bluesnarfi ng” (stealing data), “Bluejacking” (sending unsolicited messages), and “Bluebugging” (listening in on your calls).
Beware of Links and Attachments
You’ve long been warned about the risks of opening strange links and attachments— particularly those arriving in unsolicited emails or text messages. All those same warnings apply to smartphones. And those warnings also apply to calling unfamiliar phone numbers received in messages, and clicking links for app “updates.” You can ensure the authenticity of an update by going to the app’s website.
Senin, 27 Juni 2011
Setting Up Windows Home Server ‘Vail’

The beta version is in the form of a downloadable ISO, so you'll burn a DVD from ISO, or install it on a USB memory Speedlight using Microsoft Windows 7 USB DVDto tool (http://store.microsoft.com/help/ISOtool). Since no optical drive is included in this release, the configuration was run from a USB flash drive 8 GB of flash.
Basic installation took place without incident, but when the system reboots WHS office for updates, a strange problem arose. Vail had no drivers for the integrated Intel Gigabit Ethernet hardware. It does not recognize Atheros Wi-Fi adapter, but could not connect to my home network when security is enabled.
Instead of asking for a password (for Wi-Fi) or ask the hard disk (for port gigabit), the system displays a screen that says no network connection available. The only option was to "Reboot". If you reboot, you will leave the words same results other hand, in an infinite loop! Obviously, this is a mistake, but hey, this is beta software, right?
Way to avoid this error is to press Ctrl-Alt-Del when the system searches the network (but before the "network not found" window will open). The right selection key, kill the process that checks for updates and then install the driver manually.
Installing the Connector software for Individual users is easier than in the original version of WHS. No need to copy the application on a CD or USB, or manually, go to server to download it.

Instead, open a browser and type the name of http://server / connect, where the server name is the name you gave to the server during installation. Then you can download and install the WHS connector on the target system. Note that a version of the connector can be downloaded for Mac OS X and Windows.
If you have a computer set to automatically start Windows, install the WHS Connector want to disable this function. Until WHS has begun, and all passwords are set consistently, you must manually log in as this is a home server, Business Server, we recommend you log in the system, and an account! Sign in to your WHS the same. When the user names and passwords are created and are the same, you can re-enable automatic login to the computer.


Instead, open a browser and type the name of http://server / connect, where the server name is the name you gave to the server during installation. Then you can download and install the WHS connector on the target system. Note that a version of the connector can be downloaded for Mac OS X and Windows.
If you have a computer set to automatically start Windows, install the WHS Connector want to disable this function. Until WHS has begun, and all passwords are set consistently, you must manually log in as this is a home server, Business Server, we recommend you log in the system, and an account! Sign in to your WHS the same. When the user names and passwords are created and are the same, you can re-enable automatic login to the computer.
Sabtu, 18 Juni 2011
Troubleshoot and fix an unresponsive system on Windows

If you insist, however, follow the steps outlined below to troubleshoot and fix your performance issues.
Perform General Software Maintenance
If your machine is seriously lagging, perform the maintenance steps described above first. In other words, get rid of temporary files, uninstall programs you no longer need and defragment your hard drive. If it’s not too bad, start with driver and Windows updates and then do system maintenance. If you can barely do anything, however, proceed to Log Into Windows Safe Mode to troubleshoot the cause of your lag. You can also perform most maintenance steps from Safe Mode.
Perform General Hardware Maintenance
This step is underestimated. Not only can overheating significantly decrease your system performance, it’s also possible that cables became loose or hardware is starting to fail.
For general maintenance, turn off your computer and ground yourself as instructed above under Physical Hardware C. Then perform the following steps:
- Clean the fans and power supply from dirt and dust.
- Make sure all cables are connected properly.
- Control whether all cards and RAM firmly sit in their slots.
When you’re done, re-assemble everything and proceed to boot the computer into safe mode and continue the list of actions below.
If you suspect a hardware issue, you may want to remove and eventually replace hardware components one by one and see whether this has an impact on the computer’s performance.
Log Into Windows Safe Mode
Windows’ Safe Mode is a boot option that only loads the operating system with absolutely necessary basic files and drivers. It is generally used to troubleshoot issues in Windows, as many components, such as graphic drivers or software that automatically start with Windows, are not loaded.
To start in Safe Mode you need to reboot your computer. Repeatedly and gently tab the > F8 key as Windows begins to boot. If you see the Windows logo, you missed the right time point; just start over. Once you see > Advanced Boot Options you know that it worked. Use the > arrow keys on your keyboard to select > Safe Mode from the options and press > Enter to boot into Safe Mode.

If your computer no longer appears sluggish when you are in Safe Mode, you can assume that your hardware is fine. A trouble-free Safe Mode is an indicator that a software issue is the source of problems you normally see. There are still many candidates, for example a driver or software conflict, malware, or simply too many programs launching at startup.
Read the article How To Start In Windows Safe Mode & Its Uses for more background information Explained article on how to use the Windows Safe Mode as a troubleshooting tool.
Remove Software from Startup
This will free up RAM and it helps to make your system more responsive. The steps you need to take are explained in the above chapter Free RAM by Uncluttering Windows Startup.
Malware Scan and Removal
Upgrade your antivirus program (virus definitions) and run a thorough scan. Also download at least one spyware and/or adware scanner and run it. Software recommendations can be found in the above chapter.

Increase Virtual Memory
As explained above, Virtual Memory is a way for Windows to deal with an overloaded RAM. Memory of open programs that are not actively used is outsourced to the hard drive. If you are not able to upgrade your RAM, you can potentially increase your system performance by increasing the amount of Virtual Memory Windows can use. What you do is increase the Paging File size, which defines the amount of Virtual Memory that can be used once the physical RAM is exhausted.
I have mentioned previously that hard drives are very slow compared to other media, such as solid state storage devices like USB flash drives. Rather than make more Virtual Memory available on your hard drive, you can instead allocate memory storage space from your flash drive, i.e. extend your RAM with a fast data storage medium. Long-term it’s a better bet to simply buy more RAM, but if you need a short-term boost this hack can work for you.
Windows 7
In Windows 7 the feature is called ReadyBoost and you can directly access it through the properties menu of your thumb drive. Go to > Start > Computer and scroll down to > Devices with Removable Storage. Right-click on your thumb drive and select > Properties from the menu.

Switch to the > ReadyBoost tab and dedicate as much of the device to ReadyBoost as you need. Click > Apply to save the changes and wait as ReadyBoost configures the cache.

You will subsequently see the blocked out space under > Computer.

Windows 7 can handle up to eight flash drives and a total of 256 GB of Virtual Memory. However, not all flash drives satisfy the required performance characteristics’ to work with ReadyBoost. If this is the case, you will be warned.
Windows XP
Go to > Start > Control Panel > System > Advanced tab, in the > Performance category click > Properties, switch to the > Advanced tab, and under > Virtual Memory click > Change. Instead of selecting a hard drive, you can now mark a connected USB thumb drive and allocate space from this storage medium. Now take the number listed under > Space available and subtract 5 MB. Enter the resulting number under both > Initial size (MB) and > Maximum size (MB).

Click > Set and > OK to save changes, close all windows, and reboot your computer. Avoid removing the thumb drive to prevent damage.
Please note that Windows XP supports a maximum of 4096 MB in Virtual Memory.
The Virtual Memory / ReadyBoost trick was also featured in The Office Worker’s 101 Guide to a USB Thumb Drive.
Upgrade Your RAM
When you have exhausted all optimization steps in terms of software, you should consider upgrading your hardware. For both desktop computers and laptops a RAM upgrade is a cheap and easy way to boost system performance.
Before you head out to buy new RAM, however, be sure to know what you need. There are different types of RAM modules, not all will fit into your computer, and modules from different manufacturers or with differing performance should not be mixed. Besides, the memory slots in your computer are limited, and so is the maximum amount of RAM your operating system supports. Hence, before you buy anything smarten up and figure out what you need.
Jumat, 17 Juni 2011
Get Free backlink with SocialMonkee

Why Join SocialMonkee?
- SocialMonkee is FREE to join
- Allows you to build 25 BACKLINKS EVERY DAY
- All links are on UNIQUE C-Class IP addresses and domains
- Helps you dramatically increase the number of backlinks to your pages
- For better search engine indexing, rankings, and more traffic, leads and sales!
SocialMonkee is free to join, but you can upgrade your account and get access to even more features and benefits, including the ability to build 100 BACKLINKS, 3 TIMES EVERY DAY! For more information, scroll down to the ‘Upgrade to Premium’ section of this guide.
How to Use SocialMonkee
If you’re not a member yet, go to www.socialmonkee.com and sign up now. An activation email will be sent to you so make sure you use your primary email address when signing up. If you don’t receive it, please wait a few minutes and check your spam box before contacting us. Thank you.
Option 1: URL Submission – Members Area
To submit a URL to 25 sites, simply log into your account and visit the ‘Download our Firefox Plugin / Submit to Sites’ section.
Enter the URL of the page you want to build links to, at least 3 title variations (which should contain the keywords you want the page to rank for), a description with spun words or sentences and at least 3 tags (you may use the keywords you want the page to rank for).
Then select a category, choose if you want the submission to be processed now or over time and click the 'Submit' button.
Several versions of the title, description and tags are required to help make the backlinks look 100% unique to the search engines, giving them even more value and helping your pages rank even higher. Submitting a URL to SocialMonkee via the members area takes less than 2 minutes. However, there’s an even faster way... with the Firefox Plugin!
Option 2: URL Submission – Firefox Plugin (Highly Recommended)

To install the Firefox Plugin, visit the ‘Download our Firefox Plugin / Submit to Sites’ section and click the ‘Download’ button. Select ‘Open With’, choose Firefox as an application to open the file and follow the on-screen instructions. Then restart Firefox to complete the installation. If you struggle installing it, make sure you watch this video: How To Install The Firefox Plugin (2min). Once the installation is complete, you will see the ‘Monkee’ head at the bottom right of Firefox.

Once the plugin is installed, you may start using it. Click the ‘Monkee’ head at the bottom right of Firefox and choose ‘Please Login’. Enter your email address and password. Once done, click the ‘Monkee’ head again and choose ‘Submit URL’. A new window will pop up. Fill in the form and click the ‘Submit’ button. That’s all you need to do!
Upgrade to Premium
Why Upgrade?
As a Free member, you can build 25 unique backlinks, once every day. That’s a total of 175 backlinks every week, 750 every month. This is huge considering you’re not paying a single dime! If you upgrade, you will be able to build 100 unique backlinks, 3 times every day! That’s a total of 2,100 backlinks every week, 9,000 every month!

As a Premium member, you will also get access to link reports and RSS feeds, which are very useful if you want track all your backlinks and get them indexed by the search engines a lot faster. We highly recommend that you submit your RSS feeds to RSS submitters like:
- Ping-o-Matic
- Feed Shark
- Pingoat
- iPings
Doing so will help you give your backlinks even more weight. If your backlinks are not indexed by the search engines, they have little to no value, so make sure you submit the RSS feed of every of your link building campaign, for faster, better results.
How to Upgrade
There are two ways to upgrade from Free to Premium.
Option 1 - One way is to refer 12 persons to SocialMonkee. To do so, grab your affiliate link (located in the header of the site, inside the members area) and promote SocialMonkee.
Here is how your affiliate link looks like: www.socialmonkee.com/index.php?af=...
As SocialMonkee is free to join, referring 12 persons should be a piece of cake for most of you. However if you need help, make sure you visit the ‘Promo Tools’ section inside the members area. There is a huge range of promotional tools (including banners, email and blog post copies, etc.) to help you promote SocialMonkee. You can see your number of referrals in the header of the site, inside the members area, below your affiliate link.
Option 2 - The other way is to visit the ‘Upgrade to Premium’ section inside the members area and pay the one-time fee of $47. This is the fastest way to upgrade your account from Premium to Free.
If you don’t want to upgrade but want to submit a URL to 100 sites, take the one-time submission offer! Find more info on the ‘Download Firefox Plugin / Submit to sites’ page.
Support
If you need any help, please visit the FAQs Section or contact our friendly support team via our help desk: SocialMonkee Support. Make sure you watch all the videos and read the resources inside the members area before contacting us. Thank you!
We hope you enjoy using SocialMonkee as much as we do!

Why does Windows slow down???

Disk Fragmentation
On the perfect hard disk, each file is written in one contiguous piece, with no free space in front or behind it. In practice, however, files are not static. There is a continuous flow of new, growing, and shrinking files. When a file is deleted, that space in the middle of all the other files, becomes available.
Fragmentation is what happens when a file is written to small bits of free space throughout the hard disk. The NTFS file system partly solved this issue by giving priority to storing data contiguously for as long as sufficient space is available.
So what happens when a file is edited and subsequently needs more space? The information that exceeds the available space is simply written to another bit of free space, for example in place of a recently deleted file. Hence, as the hard disk fills up and when files are deleted and changed, fragmentation cannot be avoided, regardless of the file system.
Fragmentation slows Windows down because now many files consist of multiple fragments. Imagine you had to collect chapters of a single book from many different locations in the library. The hard disk’s index file knows where each fragment of a file is stored, but fetching all the fragments to open a single file consumes extra time.
The extra time required might be small, however: reading and writing data from the hard drive already is the speed-limiting step. Hard drives have not become considerably faster over the past few decades when compared to, for example, CPU performance.
Running Software and RAM
Random Access Memory (RAM) is a form of temporary data storage for the operating system and its running programs. The problem is that the amount of RAM is limited. When more space is required, the Virtual Memory Manager (VMM) scans the RAM for sections that are not in use and writes them to a swap file on the hard disk.
This outsourcing or swapping out of memory to the hard disk can slow down your system. As mentioned above, hard drives are slow compared to other data storage media and thus swapping programs in and out can cause a considerable delay.
The fault, however, often lies with the amount of software running on your computer. Each program you install can add itself to the Windows Auto Start and will subsequently eat up RAM. These programs also increase the time until Windows has fully loaded.
Space on System Drive
This issue correlates directly with the previously mentioned VMM. Windows needs space for storing temporary data on the hard drive. When the remaining space on the system drive becomes scarce, software and the entire operating system can become unresponsive as Windows frantically tries to juggle temporary data between the RAM and the limited hard disk space.
Malware
Malware is short for malicious software. It’s a piece of software, such as a virus, adware, or a worm, that you did not authorize to install but eats up your system resources anyway. It can decrease your system performance, like any other running software, and can also compromise your operating system.
Windows Registry

Almost every component of the operating system stores settings and configuration information in the Windows Registry. This includes device drivers, user profiles, and third party applications, i.e. programs. The Windows Registry is a complex hierarchical database and is continually referenced for information about the computer.
The problem with a database is that entries become outdated. Software that is removed, for example, may leave behind registry keys that no longer have any function. On the other hand, a bad program installation or a computer crash can cause conflicts or corrupt essential registry files. Any problem with the registry will cause the computer to become slow as it struggles to find the information it is looking for.
Hardware Issue
Hardware issues can be manifold. A piece of hardware could be damaged or there could be a driver conflict that causes the computer to slow down. These issues are unpredictable and often difficult to troubleshoot. Let’s look at two specific items.
Overheatinge
There is at least one fan in each computer that maintains a cool breeze of air to keep hardware components like the CPU (Central Processing Unit), power supply, and graphics card from overheating. Your computer performance can decrease significantly if your processor is overheating. Some CPUs (e.g. Intel Centrino) even throttle the processor clock speed to compensate for the heat pressure. The heat source could be a blocked fan or a failing power supply.
Graphic Card
A graphics card with ‘shared memory’ does not come with its own memory, but shares the memory of your RAM. So every time you run graphic-intensive software your graphics card will reserve its full share. If you want to avoid this a graphics card with ‘dedicated memory’ is highly recommended.
Rabu, 15 Juni 2011
Parallel Computing; Message Passing Interface

The goal of the Message-Passing Interface simply stated is to develop a widely used standard for writing message-passing programs. As such the interface should establish a practical, portable, efficient, and exible standard for message passing.
A complete list of goals follows.
- Design an application programming interface (not necessarily for compilers or a system implementation library).
- Allow efficient communication: Avoid memory-to-memory copying, allow overlap of computation and communication, and offload to communication co-processor, where available.
- Allow for implementations that can be used in a heterogeneous environment.
- Allow convenient C, C++, Fortran-77, and Fortran-95 bindings for the interface.
- Assume a reliable communication interface: the user need not cope with communication failures. Such failures are dealt with by the underlying communication subsystem.
- De ne an interface that can be implemented on many vendor's platforms, with no signi cant changes in the underlying communication and system software.
- Semantics of the interface should be language independent.
- The interface should be designed to allow for thread safety.
Point-to-Point Communication
Sending and receiving of messages by processes is the basic MPI communication mechanism. The basic point-to-point communication operations are send and receive. Their use is illustrated in the example below.
#include "mpi.h"
int main( int argc, char **argv )
{
char message[20];
int myrank;
MPI_Status status;
MPI_Init( &argc, &argv );
MPI_Comm_rank( MPI_COMM_WORLD, &myrank );
if (myrank == 0) /* code for process zero */
{
strcpy(message,"Hello, there");
MPI_Send(message, strlen(message)+1, MPI_CHAR, 1, 99, MPI_COMM_WORLD);
}
else if (myrank == 1) /* code for process one */
{
MPI_Recv(message, 20, MPI_CHAR, 0, 99, MPI_COMM_WORLD, &status);
printf("received :%s:\n", message);
}
MPI_Finalize();
}
In this example, process zero (myrank = 0) sends a message to process one using the send operation MPI_SEND. The operation speci es a send bu er in the sender memory from which the message data is taken. In the example above, the send bu er consists of the storage containing the variable message in the memory of process zero. The location, size and type of the send bu er are speci ed by the rst three parameters of the send operation. The message sent will contain the 13 characters of this variable. In addition, the send operation associates an envelope with the message. This envelope speci es the message destination and contains distinguishing information that can be used by the receive operation to select a particular message. The last three parameters of the send operation, along with the rank of the sender, specify the envelope for the message sent. Process one(myrank = 1) receives this message with the receive operation MPI_RECV. The message to be received is selected according to the value of its envelope, and the message data is stored into the receive bu er. In the example above, the receive bu er consists of the storage containing the string message in the memory of process one. The rst three parameters of the receive operation specify the location, size and type of the receive bu er. The next three parameters are used for selecting the incoming message. The last parameter is used to return information on the message just received.
The next sections describe the blocking send and receive operations. We discuss send, receive, blocking communication semantics, type matching requirements, type conversion in heterogeneous environments, and more general communication modes. Nonblocking communication is addressed next, followed by channel-like constructs and send-receive operations, Nonblocking communication is addressed next, followed by channel-like constructs and send-receive operations, ending with a description of the \dummy" process, MPI_PROC_NULL.
DERIVED DATATYPES
Up to here, all point to point communication have involved only bu ers containing a sequence of identical basic datatypes. This is too constraining on two accounts. One often wants to pass messages that contain values with di erent datatypes (e.g., an integer count, followed by a sequence of real numbers); and one often wants to send noncontiguous data(e.g., a sub-block of a matrix). One solution is to pack noncontiguous data into a contiguous bu er at the sender site and unpack it at the receiver site. This has the disadvantage of requiring additional memory-to-memory copy operations at both sites, even when the communication subsystem has scatter-gather capabilities. Instead, MPI provides mechanisms to specify more general, mixed, and noncontiguous communication bu ers. It is up to the implementation to decide whether data should be rst packed in a contiguous bu er before being transmitted, or whether it can be collected directly from where it resides.
The general mechanisms provided here allow one to transfer directly, without copying, objects of various shape and size. It is not assumed that the MPI library is cognizant of the objects declared in the host language. Thus, if one wants to transfer a structure, or an array section, it will be necessary to provide in MPI a de nition of a communication bu er that mimics the de nition of the structure or array section in question. These facilities can be used by library designers to de ne communication functions that can transfer objects defi ned in the host language | by decoding their de nitions as available in a symbol table or a dope vector. Such higher-level communication functions are not part of MPI.
More general communication bu ers are speci ed by replacing the basic datatypes that
have been used so far with derived datatypes that are constructed from basic datatypes using the constructors described in this section. These methods of constructing derived datatypes can be applied recursively.
Here is an example in C that passes an array of ints and all the processors want to send their arrays to the root with MPI_Gather:
int array[100];
int root, total_p, *receive_array;
MPI_Comm_size(comm, &total_p);
receive_array=(int *) malloc(total_p*100*sizeof(int));
MPI_Gather(array, 100, MPI_INT, receive_array, 100, MPI_INT, root, comm);
However, you may instead wish to send data as one block as opposed to 100 ints. To do this define a "contiguous block" derived data type.
MPI_Datatype newtype;
MPI_Type_contiguous(100, MPI_INT, &newtype);
MPI_Type_commit(&newtype);
MPI_Gather(array, 1, newtype, receive_array, 1, newtype, root, comm);
Passing a class or a data structure cannot use a predefined data type. MPI_Type_create_struct creates an MPI derived data type from MPI_predefined data types, as follows:
int MPI_Type_create_struct(int count, int blocklen[], MPI_Aint disp[], MPI_Datatype type[], MPI_Datatype *newtype)
where count is a number of blocks, also number of entries in blocklen[], disp[], and type[]:
- blocklen[] — number of elements in each block (array of integer)
- disp[] — byte displacement of each block (array of integer)
- type[] — type of elements in each block (array of handles to datatype objects).
The disp[] array is needed because processors require the variables to be aligned a specific way on the memory. For example, Char is one byte and can go anywhere on the memory. Short is 2 bytes, so it goes to even memory addresses. Long is 4 bytes, it goes on locations divisible by 4 and so on. The compiler tries to accommodate this architecture in a class or data structure by padding the variables. The safest way to find the distance between different variables in a data structure is by obtaining their addresses with MPI_Get_address. This function calculates the displacement of all the structure's elements from the beginning of the data structure.
Given the following data structures:
typedef struct{
int f;
short p;
} A;
typedef struct{
A a;
int pp,vp;
} B;
Here's the C code for building an MPI-derived data type:
void define_MPI_datatype(){
int blocklen[6]={1,1,1,1,1,1}; //The first and last elements mark the beg and end of data structure
MPI_Aint disp[6];
MPI_Datatype newtype;
MPI_Datatype type[6]={MPI_LB, MPI_INT, MPI_SHORT, MPI_INT, MPI_INT, MPI_UB};
B findsize[2]; //You need an array to establish the upper bound of the data structure
MPI_Aint findsize_addr, a_addr, f_addr, p_addr, pp_addr, vp_addr, UB_addr;
int error;
MPI_Get_address(&findsize[0], &findsize_addr);
MPI_Get_address(&(findsize[0]).a, &a_addr);
MPI_Get_address(&((findsize[0]).a).f, &f_addr);
MPI_Get_address(&((findsize[0]).a).p, &p_addr);
MPI_Get_address(&(findsize[0]).pp, &pp_addr);
MPI_Get_address(&(findsize[0]).vp, &vp_addr);
MPI_Get_address(&findsize[1],&UB_addr);
disp[0]=a_addr-findsize_addr;
disp[1]=f_addr-findsize_addr;
disp[2]=p_addr-findsize_addr;
disp[3]=pp_addr-findsize_addr;
disp[4]=vp_addr-findsize_addr;
disp[5]=UB_addr-findsize_addr;
error=MPI_Type_create_struct(6, blocklen, disp, type, &newtype);
MPI_Type_commit(&newtype);
One-Sided Communications
Remote Memory Access (RMA) extends the communication mechanisms of MPI by allowing one process to specify all communication parameters, both for the sending side and for the receiving side. This mode of communication facilitates the coding of some applications with dynamically changing data access patterns where the data distribution is fixed or slowly changing. In such a case, each process can compute what data it needs to access or update at other processes. However, processes may not know which data in their own memory need to be accessed or updated by remote processes, and may not even know the identity of these processes. Thus, the transfer parameters are all available only on one side. Regular send/receive communication requires matching operations by sender and receiver. In order to issue the matching operations, an application needs to distribute the transfer parameters. This may require all processes to participate in a time consuming global computation, or to periodically poll for potential communication requests to receive and act upon. The use of RMA communication mechanisms avoids the need for global computations or explicit polling. A generic example of this nature is the execution of an assignment of the form A = B(map), where map is a permutation vector, and A, B and map are distributed in the same manner.
Message-passing communication achieves two e ects: communication of data from sender to receiver; and synchronization of sender with receiver. The RMA design separates
these two functions. Three communication calls are provided: MPI_PUT (remote write), MPI_GET (remote read) and MPI_ACCUMULATE (remote update). A larger number of synchronization calls are provided that support di erent synchronization styles. The design is similar to that of weakly coherent memory systems: correct ordering of memory accesses has to be imposed by the user, using synchronization calls; the implementation can delay communication operations until the synchronization calls occur, for efficiency. The design of the RMA functions allows implementors to take advantage, in many cases, of fast communication mechanisms provided by various platforms, such as coherent or noncoherent shared memory, DMA engines, hardware-supported put/get operations, communication coprocessors, etc. The most frequently used RMA communication mechanisms can be layered on top of message-passing. However, support for asynchronous communication agents (handlers, threads, etc.) is needed, for certain RMA functions, in a distributed memory environment.
We shall denote by origin the process that performs the call, and by target the process in which the memory is accessed. Thus, in a put operation, source=origin and destination=target; in a get operation, source=target and destination=origin.
Process Creation and Management
MPI is primarily concerned with communication rather than process or resource management. However, it is necessary to address these issues to some degree in order to defi ne a useful framework for communication. This chapter presents a set of MPI interfaces that allow for a variety of approaches to process management while placing minimal restrictions on the execution environment.
The MPI model for process creation allows both the creation of an intial set of processes related by their membership in a common MPI_COMM_WORLD and the creation and management of processes after an MPI application has been started. A major impetus for the later form of process creation comes from the PVM [23] research e ort. This work has provided a wealth of experience with process management and resource control that illustrates their bene ts and potential pitfalls.
The MPI Forum decided not to address resource control because it was not able to design a portable interface that would be appropriate for the broad spectrum of existing and potential resource and process controllers. Resource control can encompass a wide range of abilities, including adding and deleting nodes from a virtual parallel machine, reserving and scheduling resources, managing compute partitions of an MPP, and returning information about available resources. assumes that resource control is provided externally-probably by computer vendors, in the case of tightly coupled systems, or by a third party software package when the environment is a cluster of workstations.
The reasons for including process management in MPI are both technical and practical. Important classes of message-passing applications require process control. These include task farms, serial applications with parallel modules, and problems that require a run-time assessment of the number and type of processes that should be started. On the practical side, users of workstation clusters who are migrating from PVM to MPI may be accustomed to using PVM's capabilities for process and resource management. The lack of these features would be a practical stumbling block to migration.
The following goals are central to the design of MPI process management:
- The MPI process model must apply to the vast majority of current parallel environments. These include everything from tightly integrated MPPs to heterogeneous networks of workstations.
- MPI must not take over operating system responsibilities. It should instead provide a clean interface between an application and system software.
- MPI must guarantee communication determinism in the presense of dynamic processes,
i.e., dynamic process management must not introduce unavoidable race conditions. - MPI must not contain features that compromise performance.
The process management model addresses these issues in two ways. First, MPI remains primarily a communication library. It does not manage the parallel environment in which a parallel program executes, though it provides a minimal interface between an application and external resource and process managers.
Second, MPI maintains a consistent concept of a communicator, regardless of how its members came into existence. A communicator is never changed once created, and it is always created using deterministic collective operations.
I/O
POSIX provides a model of a widely portable le system, but the portability and optimization needed for parallel I/O cannot be achieved with the POSIX interface.
The signifi cant optimizations required for efficiency (e.g., grouping , collective
buff ering , and disk-directed I/O ) can only be implemented if the parallel I/O system provides a high-level interface supporting partitioning of le data among processes and a collective interface supporting complete transfers of global data structures between process memories and les. In addition, further e ciencies can be gained via support for asynchronous I/O, strided accesses, and control over physical le layout on storage devices (disks). The I/O environment described in this chapter provides these facilities.
Instead of de fining I/O access modes to express the common patterns for accessing a shared file (broadcast, reduction, scatter, gather), we chose another approach in which data partitioning is expressed using derived datatypes. Compared to a limited set of predefi ned access patterns, this approach has the advantage of added exibility and expressiveness.
Pro ling Interface
To meet the MPI pro ling interface, an implementation of the MPI functions must :
- provide a mechanism through which all of the MPI de ned functions except those allowed as macros (See Section 2.6.5). This requires, in C and Fortran, an alternate entry point name, with the pre x PMPI_ for each MPI function. The pro ling interface in C++ is described in Section 16.1.10. For routines implemented as macros, it is still required that the PMPI_ version be supplied and work as expected, but it is not possible to replace at link time the MPI_ version with a user-de ned version.
- ensure that those MPI functions that are not replaced may still be linked into an executable image without causing name clashes.
- document the implementation of di erent language bindings of the MPI interface if they are layered on top of each other, so that the pro ler developer knows whether she must implement the pro le interface for each binding, or can economise by implementing it only for the lowest level routines.
- where the implementation of di erent language bindings is done through a layered approach (e.g. the Fortran binding is a set of \wrapper" functions that call the C implementation), ensure that these wrapper functions are separable from the rest of the library.
This separability is necessary to allow a separate pro ling library to be correctly implemented, since (at least with Unix linker semantics) the pro ling library must contain these wrapper functions if it is to perform as expected. This requirement allows the person who builds the pro ling library to extract these functions from the original MPI library and add them into the pro ling library without bringing along any other unnecessary code.
Implementation
'Classical' cluster and supercomputer implementations
The MPI implementation language is not constrained to match the language or languages it seeks to support at runtime. Most implementations combine C, C++ and assembly language, and target C, C++, and Fortran programmers. Bindings are available for many other languages, including Perl, Python, Ruby, Java, CL.
The initial implementation of the MPI 1.x standard was MPICH, from Argonne National Laboratory (ANL) and Mississippi State University. IBM also was an early implementor, and most early 90s supercomputer companies either commercialized MPICH, or built their own implementation. LAM/MPI from Ohio Supercomputer Center was another early open implementation. ANL has continued developing MPICH for over a decade, and now offers MPICH 2, implementing the MPI-2.1 standard. LAM/MPI and a number of other MPI efforts recently merged to form Open MPI. Many other efforts are derivatives of MPICH, LAM, and other works, including, but not limited to, commercial implementations from HP, Intel, and Microsoft.
Phython
MPI Python implementations include: pyMPI, mpi4py, pypar, MYMPI, and the MPI submodule in ScientificPython. PyMPI is notable because it is a variant python interpreter, while pypar, MYMPI, and ScientificPython's module are import modules. They make it the coder's job to decide where the call to MPI_Init belongs. Recently the well known Boost C++ Libraries acquired Boost:MPI which included the MPI Python Bindings. This is of particular help for mixing C++ and Python.
OCaml
The OCamlMPI Module implements a large subset of MPI functions and is in active use in scientific computing. An eleven thousand line OCaml program was "MPI-ified" using the module, with an additional 500 lines of code and slight restructuring and ran with excellent results on up to 170 nodes in a supercomputer.
Java
Although Java does not have an official MPI binding, several groups attempt to bridge the two, with different degrees of success and compatibility. One of the first attempts was Bryan Carpenter's mpiJava,[15] essentially a collection of JNI wrappers to a local C MPI library, resulting in a hybrid implementation with limited portability, which also has to be compiled against the specific MPI library being used.
However, this original project also defined the mpiJava API[16] (a de-facto MPI API for Java that closely followed the equivalent C++ bindings) which other subsequent Java MPI projects adopted. An alternative, less–used API is MPJ API,[17] designed to be more object-oriented and closer to Sun Microsystems' coding conventions. Beyond the API, Java MPI libraries can be either dependent on a local MPI library, or implement the message passing functions in Java, while some like P2P-MPI also provide peer-to-peer functionality and allow mixed platform operation.
Some of the most challenging parts of Java/MPI arise from Java characteristics such as the lack of explicit pointers and the linear memory address space for its objects, which make transferring multidimensional arrays and complex objects inefficient. Workarounds usually involve transferring one line at a time and/or performing explicit de-serialization and casting at both sending and receiving ends, simulating C or FORTRAN-like arrays by the use of a one-dimensional array, and pointers to primitive types by the use of single-element arrays, thus resulting in programming styles quite far from Java conventions.
The most usable Java message passing system is MPJ Express[citation needed]. Recent versions can be executed in cluster and multicore configurations. In the cluster configuration, it can execute parallel Java applications on clusters and clouds. Here Java sockets or specialized I/O interconnects like Myrinet can support messaging between MPJ Express processes. In the multicore configuration, a parallel Java application is executed on multicore processors. In this mode, MPJ Express processes are represented by Java threads. New users are encouraged to start in multicore mode before moving to clusters or clouds.
Common Language Infrastructure
The two managed CLI (.NET) implementations are Pure Mpi.NET[18] and MPI.NET,[19] a research effort at Indiana University licensed under a BSD-style license. It is compatible with Mono, and can make full use of underlying low-latency MPI network fabrics.
Hardware implementations
MPI hardware research focuses on implementing MPI directly in hardware, for example via Processor-in-memory, building MPI operations into the microcircuitry of the RAM chips in each node. By implication, this approach is independent of the language, OS or CPU, but cannot be readily updated or removed.
Another approach has been to add hardware acceleration to one or more parts of the operation, including hardware processing of MPI queues and using RDMA to directly transfer data between memory and the network interface without CPU or OS kernel intervention.
Example program
Here is a "Hello World" program in MPI written in C. In this example, we send a "hello" message to each processor, manipulate it trivially, return the results to the main process, and print the messages.
/*
"Hello World" MPI Test Program
*/
#include
#include
#include
#define BUFSIZE 128
#define TAG 0
int main(int argc, char *argv[])
{
char idstr[32];
char buff[BUFSIZE];
int numprocs;
int myid;
int i;
MPI_Status stat;
MPI_Init(&argc,&argv); /* all MPI programs start with MPI_Init; all 'N' processes exist thereafter */
MPI_Comm_size(MPI_COMM_WORLD,&numprocs); /* find out how big the SPMD world is */
MPI_Comm_rank(MPI_COMM_WORLD,&myid); /* and this processes' rank is */
/* At this point, all programs are running equivalently, the rank distinguishes
the roles of the programs in the SPMD model, with rank 0 often used specially... */
if(myid == 0)
{
printf("%d: We have %d processors\n", myid, numprocs);
for(i=1;i numprocs;i++)
{
sprintf(buff, "Hello %d! ", i);
MPI_Send(buff, BUFSIZE, MPI_CHAR, i, TAG, MPI_COMM_WORLD);
}
for(i=1;inumprocs;i++)
{
MPI_Recv(buff, BUFSIZE, MPI_CHAR, i, TAG, MPI_COMM_WORLD, &stat);
printf("%d: %s\n", myid, buff);
}
}
else
{
/* receive from rank 0: */
MPI_Recv(buff, BUFSIZE, MPI_CHAR, 0, TAG, MPI_COMM_WORLD, &stat);
sprintf(idstr, "Processor %d ", myid);
strncat(buff, idstr, BUFSIZE-1);
strncat(buff, "reporting for duty\n", BUFSIZE-1);
/* send to rank 0: */
MPI_Send(buff, BUFSIZE, MPI_CHAR, 0, TAG, MPI_COMM_WORLD);
}
MPI_Finalize(); /* MPI Programs end with MPI Finalize; this is a weak synchronization point */
return 0;
}
Note that the runtime environment for the MPI implementation used (often called mpirun or mpiexec) spawns multiple copies of the program, with the total number of copies determining the number of process ranks in MPI_COMM_WORLD, which is an opaque descriptor for communication between the set of processes. A Single-Program-Multiple-Data (SPMD) programming model is thereby facilitated, but not required; many MPI implementations allow multiple, different, executables to be started in the same MPI job. Each process has its own rank, the total number of processes in the world, and the ability to communicate between them either with point-to-point (send/receive) communication, or by collective communication among the group. It is enough for MPI to provide an SPMD-style program with MPI_COMM_WORLD, its own rank, and the size of the world to allow algorithms to decide what to do. In more realistic situations, I/O is more carefully managed than in this example. MPI does not guarantee how POSIX I/O would actually work on a given system, but it commonly does work, at least from rank 0.
MPI uses the notion of process rather than processor. Program copies are mapped to processors by the MPI runtime. In that sense, the parallel machine can map to 1 physical processor, or N where N is the total number of processors available, or something in between. For maximum parallel speedup, more physical processors are used. This example adjusts its behavior to the size of the world N, so it also seeks to scale to the runtime configuration without compilation for each size variation, although runtime decisions might vary depending on that absolute amount of concurrency available.
Download
LAM 7.1.4 Downloads
MPI.NET Source Code (Windows)
Rabu, 25 Mei 2011
Accessing the Registry key from DOS Prompt

One is to handle the Windows system registry,
Do not believe ...? Prove it ...!!!
Regedit.exe is a tool created to access the registry with windows based.
Reg.exe is a tool created to access the registry with DOS-based (console).
How do I access it?
- Go to DOS console
- Type the command reg.
It will display some Operation options that you can use to access the Windows registry, such as: QUERY, ADD, DELETE, COPY, SAVE, LOAD, unload, Restore, Compare, EXPORT, IMPORT. - Type reg add /?
It will display the parameters-parameters that can be incorporated into the ADD command.
With this brief introduction, you can access the registry in DOS (console).
====================================
Rootkey:
HKCR = HKEY_CLASSES_ROOT
HKCU = HKEY_CURRENT_USER
HKLM = HKEY_LOCAL_MACHINE
HKU = HKEY_USERS
HKCC = HKEY_CURRENT_CONFIG
Data Type:
REG_SZ = String Value
REG_MULTI_SZ = Multi-String Value
REG_DWORD = DWORD Value
REG_BINARY = Binary Value
REG_NONE = No Value
====================================
Example :
reg add “HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System” /v DisableRegistryTools /t reg_dword /d 1 /f
This command will disable the Windows-based regedit.
Meanwhile, to enable regedit is with the following command:
reg add “HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System” /v DisableRegistryTools /t reg_dword /d 0 /f
or
reg delete “HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System” /v DisableRegistryTools
Similarly to other commands.
This technique is very powerful tool used to handle various kinds of viruses that could make you upset with the doings at his behavior. Block it, block here ...
Be careful ...!! could be a virus change this reg.exe file triggers the virus.
My advice: save the file reg.exe this in a secure storage media such as CD, Flash Disk, etc.. and keep out of reach of viruses. One day you'll need it.

This is just an alternative if regedit blocked by the Administrator or a virus.














