sometimes to advance you have to make a step back.

use plain vertex arrays instead of VBOs to render in Opengl plugin as the nature of the data make VBOs slower. This must bring, depending on the implementation, a good speedup in opengl.
in my system now opengl and d3d9 have a difference of 1 to 5 fps depending of the game.
some cleanup and a little work pointing to future improvements in the way of rendering.
please test and check for any errors.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6139 8ced0084-cf51-0410-be5f-012b33b47a6e

Source/Core/Common/Src/Hash.cpp

@@ -119,3 +119,119 @@ u32 HashEctor(const u8* ptr, int length)
 
 	return(crc);
 }
+
+#ifdef _M_X64
+u64 GetHash64(const u8 *src, int len, u32 samples)
+{
+	const u64 m = 0xc6a4a7935bd1e995;
+	const int r = 47;
+
+	u64 h = len * m;
+	u32 Step = (len/8);
+	const u64 * data = (const u64 *)src;
+	const u64 * end = data + Step;
+	if(samples == 0) samples = Step;
+	Step  = Step / samples;
+	if(Step < 1) Step = 1;
+	while(data < end)
+	{
+		u64 k = data[0];
+		data+=Step;
+		k *= m; 
+		k ^= k >> r; 
+		k *= m; 		
+		h ^= k;
+		h *= m; 
+	}
+
+	const u8 * data2 = (const u8*)end;
+
+	switch(len & 7)
+	{
+	case 7: h ^= u64(data2[6]) << 48;
+	case 6: h ^= u64(data2[5]) << 40;
+	case 5: h ^= u64(data2[4]) << 32;
+	case 4: h ^= u64(data2[3]) << 24;
+	case 3: h ^= u64(data2[2]) << 16;
+	case 2: h ^= u64(data2[1]) << 8;
+	case 1: h ^= u64(data2[0]);
+	        h *= m;
+	};
+ 
+	h ^= h >> r;
+	h *= m;
+	h ^= h >> r;
+
+	return h;
+} 
+
+#else
+u64 GetHash64(const u8 *src, int len, u32 samples)
+{
+	const u32 m = 0x5bd1e995;
+	const int r = 24;
+	
+	u32 h1 = len;
+	u32 h2 = 0;
+
+	u32 Step = (len / 4);
+	const u32 * data = (const u32 *)src;
+	const u32 * end = data + Step;
+	const u8 * uEnd = (const u8 *)end;
+	if(samples == 0) samples = Step;
+	Step = Step / samples;
+
+	if(Step < 2) Step = 2;	
+
+	while(data < end)
+	{
+		u32 k1 = data[0];
+		k1 *= m; 
+		k1 ^= k1 >> r; 
+		k1 *= m;
+		h1 *= m; 
+		h1 ^= k1;
+		
+
+		u32 k2 = data[1];
+		k2 *= m; 
+		k2 ^= k2 >> r; 
+		k2 *= m;
+		h2 *= m; 
+		h2 ^= k2;
+		data+=Step;
+	}
+
+	if((len & 7) > 3)
+	{
+		u32 k1 = *(end - 1);
+		k1 *= m; 
+		k1 ^= k1 >> r; 
+		k1 *= m;
+		h1 *= m; 
+		h1 ^= k1;
+		len -= 4;
+	}
+
+	switch(len & 3)
+	{
+	case 3: h2 ^= uEnd[2] << 16;
+	case 2: h2 ^= uEnd[1] << 8;
+	case 1: h2 ^= uEnd[0];
+			h2 *= m;
+	};
+
+	h1 ^= h2 >> 18; h1 *= m;
+	h2 ^= h1 >> 22; h2 *= m;
+	h1 ^= h2 >> 17; h1 *= m;
+	h2 ^= h1 >> 19; h2 *= m;
+
+	u64 h = h1;
+
+	h = (h << 32) | h2;
+
+	return h;
+}
+
+
+#endif

Source/Core/Common/Src/Hash.h

@@ -24,5 +24,5 @@ u32 HashFletcher(const u8* data_u8, size_t length);  // FAST. Length & 1 == 0.
 u32 HashAdler32(const u8* data, size_t len);         // Fairly accurate, slightly slower
 u32 HashFNV(const u8* ptr, int length);              // Another fast and decent hash
 u32 HashEctor(const u8* ptr, int length);            // JUNK. DO NOT USE FOR NEW THINGS
-
+u64 GetHash64(const u8 *src, int len, u32 samples);
 #endif // _HASH_H_

Source/Core/Common/Src/LinearDiskCache.cpp

@@ -22,7 +22,7 @@ static const char ID[4] = {'D', 'C', 'A', 'C'};
 // Update this to the current SVN revision every time you change shader generation code.
 // We don't automatically get this from SVN_REV because that would mean regenerating the
 // shader cache for every revision, graphics-related or not, which is simply annoying.
-const int version = 6124;
+const int version = 6139;
 
 LinearDiskCache::LinearDiskCache() 
 	: file_(NULL), num_entries_(0) {