Made LinearDiskCache a template class. Keys are now some POD type (fixed size). Eliminates casting and key size checking.

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

Source/Core/Common/Common.vcproj

@@ -701,10 +701,6 @@
 			RelativePath=".\Src\IniFile.h"
 			>
 		</File>
-		<File
-			RelativePath=".\Src\LinearDiskCache.cpp"
-			>
-		</File>
 		<File
 			RelativePath=".\Src\LinearDiskCache.h"
 			>

Source/Core/Common/Src/LinearDiskCache.cpp

@@ -1,172 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#include "LinearDiskCache.h"
-
-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 = 6306;
-
-LinearDiskCache::LinearDiskCache() 
-	: file_(NULL), num_entries_(0) {
-}
-
-void LinearDiskCache::WriteHeader() {
-	fwrite(ID, 4, 1, file_);
-	fwrite(&version, 4, 1, file_);
-}
-
-bool LinearDiskCache::ValidateHeader() {
-	char header_id[4];
-	int header_version;
-	fread(&header_id, 4, 1, file_);
-	fread(&header_version, 4, 1, file_);
-	if (memcmp(header_id, ID, 4) != 0)
-		return false;
-	if (header_version != version)
-		return false;
-	return true;
-}
-
-int LinearDiskCache::OpenAndRead(const char *filename, LinearDiskCacheReader *reader) {
-	if (file_)
-	{
-		ERROR_LOG(VIDEO, "LinearDiskCache trying to open an alredy opened cache");
-		return 0;
-	}
-	int items_read_count = 0;
-	file_ = fopen(filename, "rb");
-	int file_size = 0;
-	if (file_) {
-		fseek(file_, 0, SEEK_END);
-		file_size = (int)ftell(file_);
-	}
-
-	bool file_corrupt = false;
-	if (file_size == 0) {
-		if (file_)
-			fclose(file_);
-		// Reopen for writing.
-		file_ = fopen(filename, "wb");
-		// Cache empty, let's initialize a header.
-		WriteHeader();
-		num_entries_ = 0;
-	} else {
-		// file_ must be != 0 here.
-		// Back to the start we go.
-		fseek(file_, 0, SEEK_SET);
-		// Check that the file is valid
-		if (!ValidateHeader()) {
-			// Not valid - delete the file and start over.
-			fclose(file_);
-			unlink(filename);
-
-			// PanicAlert("LinearDiskCache file header broken.");
-
-			file_ = fopen(filename, "wb");
-			WriteHeader();
-			num_entries_ = 0;
-		} else {
-			// Valid - blow through it.
-			// We're past the header already thanks to ValidateHeader.
-			while (!feof(file_)) {
-				int key_size, value_size;
-				size_t key_size_size = fread(&key_size, 1, sizeof(key_size), file_);
-				size_t value_size_size = fread(&value_size, 1, sizeof(value_size), file_);
-				if (key_size_size == 0 && value_size_size == 0) {
-					// I guess feof isn't doing it's job - we're at the end.
-					break;
-				}
-				if (key_size <= 0 || value_size < 0 || key_size_size != 4 || value_size_size != 4) {
-					// PanicAlert("Disk cache file %s corrupted/truncated! ks: %i vs %i kss %i vss %i", filename,
-					//	key_size, value_size, key_size_size, value_size_size);
-					file_corrupt = true;
-					break;
-				}
-				u8 *key = new u8[key_size];
-				u8 *value = new u8[value_size];
-				int actual_key_size = (int)fread(key, 1, key_size, file_);
-				int actual_value_size = (int)fread(value, 1, value_size, file_);
-				if (actual_key_size != key_size || actual_value_size != value_size) {
-					// PanicAlert("Disk cache file %s corrupted/truncated! ks: %i  actual ks: %i   vs: %i  actual vs: %i", filename,
-					// 	key_size, actual_key_size, value_size, actual_value_size);
-					file_corrupt = true;
-				} else {
-					reader->Read(key, key_size, value, value_size);
-					items_read_count++;
-				}
-				delete [] key;
-				delete [] value;
-			}
-			fclose(file_);
-			// Done reading.
-
-			// Reopen file for append.
-			// At this point, ftell() will be at the end of the file,
-			// which happens to be exactly what we want.
-			file_ = fopen(filename, "ab");
-			fseek(file_, 0, SEEK_END);
-		}
-	}
-
-	if (file_corrupt) {
-		// Restore sanity, start over.
-		fclose(file_);
-		unlink(filename);
-
-		file_ = fopen(filename, "wb+");
-		WriteHeader();
-	}
-
-	return items_read_count;
-}
-
-void LinearDiskCache::Append(
-	const u8 *key, int key_size, const u8 *value, int value_size) {
-	// Should do a check that we don't already have "key"?
-	fwrite(&key_size, 1, sizeof(key_size), file_);
-	fwrite(&value_size, 1, sizeof(value_size), file_);
-	fwrite(key, 1, key_size, file_);
-	fwrite(value, 1, value_size, file_);
-}
-
-void LinearDiskCache::Sync() {
-	if (file_)
-	{
-		fflush(file_);
-	}
-	else
-	{
-		ERROR_LOG(VIDEO, "LinearDiskCache trying to sync closed cache");
-	}
-}
-
-void LinearDiskCache::Close() {
-	if (file_)
-	{
-		fclose(file_);
-		file_ = 0;
-		num_entries_ = 0;
-	}
-	else 
-	{
-		ERROR_LOG(VIDEO, "LinearDiskCache trying to close an alredy closed cache");
-	}
-}

Source/Core/Common/Src/LinearDiskCache.h

@@ -19,21 +19,35 @@
 #define _LINEAR_DISKCACHE
 
 #include "Common.h"
+#include <fstream>
 
-#include <stdlib.h>
-#include <stdio.h>
+// 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.
+enum
+{
+	LINEAR_DISKCACHE_VER = 6420
+};
 
 // On disk format:
-// uint32 'DCAC'
-// uint32 version;  // svn_rev
-// uint32 key_length;
-// uint32 value_length;
-// ....   key;
-// ....   value;
+//header{
+// u32 'DCAC';
+// u32 version;  // svn_rev
+// u16 sizeof(key_type);
+// u16 sizeof(value_type);
+//}
 
-class LinearDiskCacheReader {
+//key_value_pair{
+// u32 value_size;
+// key_type   key;
+// value_type[value_size]   value;
+//}
+
+template <typename K, typename V>
+class LinearDiskCacheReader
+{
 public:
-	virtual void Read(const u8 *key, int key_size, const u8 *value, int value_size) = 0;
+	virtual void Read(const K &key, const V *value, u32 value_size) = 0;
 };
 
 // Dead simple unsorted key-value store with append functionality.
@@ -44,24 +58,123 @@ public:
 // Not tuned for extreme performance but should be reasonably fast.
 // Does not support keys or values larger than 2GB, which should be reasonable.
 // Keys must have non-zero length; values can have zero length.
-class LinearDiskCache {
-public:
-	LinearDiskCache();
 
-	// Returns the number of items read from the cache.
-	int OpenAndRead(const char *filename, LinearDiskCacheReader *reader);
-	void Close();
-	void Sync();
+// K and V are some POD type
+// K : the key type
+// V : value array type
+template <typename K, typename V>
+class LinearDiskCache
+{
+public:
+	// return number of read entries
+	u32 OpenAndRead(const char *filename, LinearDiskCacheReader<K, V> &reader)
+	{
+		using std::ios_base;
+
+		// close any currently opened file
+		Close();
+
+		// try opening for reading/writing
+		m_file.open(filename, ios_base::in | ios_base::out | ios_base::binary);
+		
+		if (m_file.is_open() && ValidateHeader())
+		{
+			// good header, read some key/value pairs
+			u32 num_entries = 0;
+			K key;
+
+			V *value = NULL;
+			u32 value_size;
+
+			while (Read(&value_size))
+			{
+				delete[] value;
+				value = new V[value_size];
+
+				// read key/value and pass to reader
+				if (Read(&key) && Read(value, value_size))
+					reader.Read(key, value, value_size);
+				else
+					break;
+
+				++num_entries;
+			}
+
+			delete[] value;
+			return num_entries;
+		}
+
+		// failed to open file for reading or bad header
+		// close and recreate file
+		Close();
+		m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary);
+		WriteHeader();
+		return 0;
+	}
+	
+	void Sync()
+	{
+		m_file.flush();
+	}
+
+	void Close()
+	{
+		if (m_file.is_open())
+			m_file.close();
+		// clear any error flags
+		m_file.clear();
+	}
 
 	// Appends a key-value pair to the store.
-	void Append(const u8 *key, int key_size, const u8 *value, int value_size);
+	void Append(const K &key, const V *value, u32 value_size)
+	{
+		// TODO: Should do a check that we don't already have "key"?
+		Write(&value_size);
+		Write(&key);
+		Write(value, value_size);
+	}
 
 private:
-	void WriteHeader();
-	bool ValidateHeader();
+	void WriteHeader()
+	{
+		Write(&m_header);
+	}
 
-	FILE *file_;
-	int num_entries_;
+	bool ValidateHeader()
+	{
+		char file_header[sizeof(Header)];
+
+		return (Read(file_header, sizeof(Header))
+			&& !memcmp((const char*)&m_header, file_header, sizeof(Header)));
+	}
+
+	template <typename D>
+	bool Write(const D *data, u32 count = 1)
+	{
+		return m_file.write((const char*)data, count * sizeof(D)).good();
+	}
+
+	template <typename D>
+	bool Read(const D *data, u32 count = 1)
+	{
+		return m_file.read((char*)data, count * sizeof(D)).good();
+	}
+
+	struct Header
+	{
+		Header()
+			: id(*(u32*)"DCAC")
+			, ver(LINEAR_DISKCACHE_VER)
+			, key_t_size(sizeof(K))
+			, value_t_size(sizeof(V))
+		{}
+
+		const u32 id, ver;
+		const u16 key_t_size, value_t_size;
+
+	} m_header;
+
+	std::fstream m_file;
 };
 
 #endif  // _LINEAR_DISKCACHE

Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp

@@ -26,7 +26,7 @@ namespace D3D
 {
 
 // bytecode->shader
-ID3D11VertexShader* CreateVertexShaderFromByteCode(void* bytecode, unsigned int len)
+ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len)
 {
 	ID3D11VertexShader* v_shader;
 	HRESULT hr = D3D::device->CreateVertexShader(bytecode, len, NULL, &v_shader);
@@ -71,7 +71,7 @@ bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
 }
 
 // bytecode->shader
-ID3D11PixelShader* CreatePixelShaderFromByteCode(void* bytecode, unsigned int len)
+ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len)
 {
 	ID3D11PixelShader* p_shader;
 	HRESULT hr = D3D::device->CreatePixelShader(bytecode, len, NULL, &p_shader);

Source/Plugins/Plugin_VideoDX11/Src/D3DShader.h

@@ -21,8 +21,8 @@
 
 namespace D3D
 {
-	ID3D11VertexShader* CreateVertexShaderFromByteCode(void* bytecode, unsigned int len);
-	ID3D11PixelShader* CreatePixelShaderFromByteCode(void* bytecode, unsigned int len);
+	ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len);
+	ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len);
 
 	// The returned bytecode buffers should be Release()d.
 	bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob);

Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp

@@ -38,7 +38,7 @@ extern int frameCount;
 PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
 const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry;
 
-LinearDiskCache g_ps_disk_cache;
+LinearDiskCache<PIXELSHADERUID, u8> g_ps_disk_cache;
 
 ID3D11PixelShader* s_ColorMatrixProgram = NULL;
 ID3D11PixelShader* s_ColorCopyProgram = NULL;
@@ -158,17 +158,12 @@ void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const
 }
 
 // this class will load the precompiled shaders into our cache
-class PixelShaderCacheInserter : public LinearDiskCacheReader {
+class PixelShaderCacheInserter : public LinearDiskCacheReader<PIXELSHADERUID, u8>
+{
 public:
-	void Read(const u8* key, int key_size, const u8* value, int value_size)
+	void Read(const PIXELSHADERUID &key, const u8 *value, u32 value_size)
 	{
-		PIXELSHADERUID uid;
-		if (key_size != sizeof(uid)) {
-			ERROR_LOG(VIDEO, "Wrong key size in pixel shader cache");
-			return;
-		}
-		memcpy(&uid, key, key_size);
-		PixelShaderCache::InsertByteCode(uid, (void*)value, value_size);
+		PixelShaderCache::InsertByteCode(key, value, value_size);
 	}
 };
 
@@ -205,7 +200,7 @@ void PixelShaderCache::Init()
 	char cache_filename[MAX_PATH];
 	sprintf(cache_filename, "%sdx11-%s-ps.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id);
 	PixelShaderCacheInserter inserter;
-	g_ps_disk_cache.OpenAndRead(cache_filename, &inserter);
+	g_ps_disk_cache.OpenAndRead(cache_filename, inserter);
 }
 
 // ONLY to be used during shutdown.
@@ -266,7 +261,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 	}
 
 	// Insert the bytecode into the caches
-	g_ps_disk_cache.Append((u8*)&uid, sizeof(uid), (const u8*)pbytecode->Data(), pbytecode->Size());
+	g_ps_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());
 	g_ps_disk_cache.Sync();
 
 	bool result = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size());
@@ -275,7 +270,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 	return result;
 }
 
-bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, void* bytecode, unsigned int bytecodelen)
+bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen)
 {
 	ID3D11PixelShader* shader = D3D::CreatePixelShaderFromByteCode(bytecode, bytecodelen);
 	if (shader == NULL)

Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h

@@ -33,7 +33,7 @@ public:
 	static void Clear();
 	static void Shutdown();
 	static bool SetShader(DSTALPHA_MODE dstAlphaMode, u32 components);
-	static bool InsertByteCode(const PIXELSHADERUID &uid, void* bytecode, unsigned int bytecodelen);
+	static bool InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen);
 
 	static ID3D11PixelShader* GetColorMatrixProgram();
 	static ID3D11PixelShader* GetColorCopyProgram();

Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp

@@ -40,7 +40,7 @@ static ID3D11VertexShader* ClearVertexShader = NULL;
 static ID3D11InputLayout* SimpleLayout = NULL;
 static ID3D11InputLayout* ClearLayout = NULL;
 
-LinearDiskCache g_vs_disk_cache;
+LinearDiskCache<VERTEXSHADERUID, u8> g_vs_disk_cache;
 
 ID3D11VertexShader* VertexShaderCache::GetSimpleVertexShader() { return SimpleVertexShader; }
 ID3D11VertexShader* VertexShaderCache::GetClearVertexShader() { return ClearVertexShader; }
@@ -81,21 +81,15 @@ void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const
 }
 
 // this class will load the precompiled shaders into our cache
-class VertexShaderCacheInserter : public LinearDiskCacheReader {
+class VertexShaderCacheInserter : public LinearDiskCacheReader<VERTEXSHADERUID, u8>
+{
 public:
-	void Read(const u8 *key, int key_size, const u8 *value, int value_size)
+	void Read(const VERTEXSHADERUID &key, const u8 *value, u32 value_size)
 	{
-		VERTEXSHADERUID uid;
-		if (key_size != sizeof(uid))
-		{
-			ERROR_LOG(VIDEO, "Wrong key size in vertex shader cache");
-			return;
-		}
-		memcpy(&uid, key, key_size);
-
 		D3DBlob* blob = new D3DBlob(value_size, value);
-		VertexShaderCache::InsertByteCode(uid, blob);
+		VertexShaderCache::InsertByteCode(key, blob);
 		blob->Release();
+
 	}
 };
 
@@ -183,7 +177,7 @@ void VertexShaderCache::Init()
 	char cache_filename[MAX_PATH];
 	sprintf(cache_filename, "%sdx11-%s-vs.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id);
 	VertexShaderCacheInserter inserter;
-	g_vs_disk_cache.OpenAndRead(cache_filename, &inserter);
+	g_vs_disk_cache.OpenAndRead(cache_filename, inserter);
 }
 
 void VertexShaderCache::Clear()
@@ -238,7 +232,7 @@ bool VertexShaderCache::SetShader(u32 components)
 		PanicAlert("Failed to compile Vertex Shader %s %d:\n\n%s", __FILE__, __LINE__, code);
 		return false;
 	}
-	g_vs_disk_cache.Append((u8*)&uid, sizeof(uid), (const u8*)pbytecode->Data(), pbytecode->Size());
+	g_vs_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());
 	g_vs_disk_cache.Sync();
 
 	bool result = InsertByteCode(uid, pbytecode);

Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp

@@ -41,7 +41,7 @@
 PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
 const PixelShaderCache::PSCacheEntry *PixelShaderCache::last_entry;
 
-static LinearDiskCache g_ps_disk_cache;
+static LinearDiskCache<PIXELSHADERUID, u8> g_ps_disk_cache;
 static std::set<u32> unique_shaders;
 
 #define MAX_SSAA_SHADERS 3
@@ -87,17 +87,12 @@ void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const
 	D3D::dev->SetPixelShaderConstantF(const_number, f, count);
 }
 
-class PixelShaderCacheInserter : public LinearDiskCacheReader {
+class PixelShaderCacheInserter : public LinearDiskCacheReader<PIXELSHADERUID, u8>
+{
 public:
-	void Read(const u8 *key, int key_size, const u8 *value, int value_size)
+	void Read(const PIXELSHADERUID &key, const u8 *value, u32 value_size)
 	{
-		PIXELSHADERUID uid;
-		if (key_size != sizeof(uid)) {
-			ERROR_LOG(VIDEO, "Wrong key size in pixel shader cache");
-			return;
-		}
-		memcpy(&uid, key, key_size);
-		PixelShaderCache::InsertByteCode(uid, value, value_size, false);
+		PixelShaderCache::InsertByteCode(key, value, value_size, false);
 	}
 };
 
@@ -239,7 +234,7 @@ void PixelShaderCache::Init()
 	char cache_filename[MAX_PATH];
 	sprintf(cache_filename, "%sdx9-%s-ps.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id);
 	PixelShaderCacheInserter inserter;
-	g_ps_disk_cache.OpenAndRead(cache_filename, &inserter);
+	g_ps_disk_cache.OpenAndRead(cache_filename, inserter);
 }
 
 // ONLY to be used during shutdown.
@@ -345,7 +340,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 	}
 
 	// Insert the bytecode into the caches
-	g_ps_disk_cache.Append((u8 *)&uid, sizeof(uid), bytecode, bytecodelen);
+	g_ps_disk_cache.Append(uid, bytecode, bytecodelen);
 	g_ps_disk_cache.Sync();
 
 	// And insert it into the shader cache.

Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp

@@ -42,7 +42,7 @@ const VertexShaderCache::VSCacheEntry *VertexShaderCache::last_entry;
 static LPDIRECT3DVERTEXSHADER9 SimpleVertexShader[MAX_SSAA_SHADERS];
 static LPDIRECT3DVERTEXSHADER9 ClearVertexShader;
 
-LinearDiskCache g_vs_disk_cache;
+LinearDiskCache<VERTEXSHADERUID, u8> g_vs_disk_cache;
 
 LPDIRECT3DVERTEXSHADER9 VertexShaderCache::GetSimpleVertexShader(int level)
 {
@@ -54,7 +54,6 @@ LPDIRECT3DVERTEXSHADER9 VertexShaderCache::GetClearVertexShader()
 	return ClearVertexShader;
 }
 
-
 void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
 {
 	const float f[4] = { f1, f2, f3, f4 };
@@ -85,19 +84,12 @@ void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const
 }
 
 // this class will load the precompiled shaders into our cache
-class VertexShaderCacheInserter : public LinearDiskCacheReader {
+class VertexShaderCacheInserter : public LinearDiskCacheReader<VERTEXSHADERUID, u8>
+{
 public:
-	void Read(const u8 *key, int key_size, const u8 *value, int value_size)
+	void Read(const VERTEXSHADERUID &key, const u8 *value, u32 value_size)
 	{
-		VERTEXSHADERUID uid;
-		if (key_size != sizeof(uid))
-		{
-			ERROR_LOG(VIDEO, "Wrong key size in vertex shader cache");
-			return;
-		}
-		memcpy(&uid, key, key_size);
-
-		VertexShaderCache::InsertByteCode(uid, value, value_size, false);
+		VertexShaderCache::InsertByteCode(key, value, value_size, false);
 	}
 };
 
@@ -182,7 +174,7 @@ void VertexShaderCache::Init()
 	char cache_filename[MAX_PATH];
 	sprintf(cache_filename, "%sdx9-%s-vs.cache", File::GetUserPath(D_SHADERCACHE_IDX), globals->unique_id);
 	VertexShaderCacheInserter inserter;
-	g_vs_disk_cache.OpenAndRead(cache_filename, &inserter);
+	g_vs_disk_cache.OpenAndRead(cache_filename, inserter);
 }
 
 void VertexShaderCache::Clear()
@@ -257,7 +249,7 @@ bool VertexShaderCache::SetShader(u32 components)
 		}
 		return false;
 	}
-	g_vs_disk_cache.Append((u8 *)&uid, sizeof(uid), bytecode, bytecodelen);
+	g_vs_disk_cache.Append(uid, bytecode, bytecodelen);
 	g_vs_disk_cache.Sync();
 
 	bool result = InsertByteCode(uid, bytecode, bytecodelen, true);