Appfabric Cache funciona 4 veces más lento que SQL Server 2008 ??

Question

Estoy ejecutando una prueba en la que estoy comparando el tiempo de recuperación b/w appfabric y SQL Server 2008 y parece que appFabric está funcionando 4 veces más lento que SQL Server.

Tengo una instalación de SQL Server 2008 que contiene solo una tabla con 4 columnas (todas nvarchar). La tabla tiene 6000 filas. Inserté la misma fila (como obj serializable CLR) en la memoria caché de la aplicación. Estoy ejecutando un ciclo para obtener datos x veces.

Este es el código

public class AppFabricCache 
{ 
readonly DataCache myDefaultCache; 

public AppFabricCache() 
{ 
//------------------------- 
// Configure Cache Client 
//------------------------- 

//Define Array for 1 Cache Host 
var servers = new List<DataCacheServerEndpoint>(1); 

//Specify Cache Host Details 
// Parameter 1 = host name 
// Parameter 2 = cache port number 
servers.Add(new DataCacheServerEndpoint(@"localhost", 22233)); 

//Create cache configuration 
var configuration = new DataCacheFactoryConfiguration(); 

//Set the cache host(s) 
configuration.Servers = servers; 

//Set default properties for local cache (local cache disabled) 
configuration.LocalCacheProperties = new DataCacheLocalCacheProperties(); 

//Disable exception messages since this sample works on a cache aside 
DataCacheClientLogManager.ChangeLogLevel(System.Diagnostics.TraceLevel.Off); 

//Pass configuration settings to cacheFactory constructor 
DataCacheFactory myCacheFactory = new DataCacheFactory(configuration); 

//Get reference to named cache called "default" 
myDefaultCache = myCacheFactory.GetCache("default"); 
} 

public bool TryGetCachedObject(string key, out object value) 
{ 
value = myDefaultCache.Get(key); 
bool result = value != null; 
return result; 
} 

public void PutItemIntoCache(string key, object value) 
{ 
myDefaultCache.Put(key, value, TimeSpan.FromDays(365)); 
} 

} 

Y aquí está el bucle para obtener los datos de la caché

public double RunReadStressTest(int numberOfIterations, out int recordReadCount) 
{ 
recordReadCount = 0; 
Stopwatch sw = Stopwatch.StartNew(); 
for (int i = 0; i < numberOfIterations; i++) 
{ 
for (int j = 1; j <= 6000; j++) 
{ 
string posId = "PosId-" + j; 
try 
{ 
object value; 
if (TryGetCachedObject(posId, out value)) 
recordReadCount++; 
} 
catch (Exception e) 
{ 
Trace.WriteLine("AS%% - Exception - " + e.Message); 
} 
} 
} 
sw.Stop(); 
return sw.ElapsedMilliseconds; 
} 
} 

Tengo exactamente la misma lógica para recuperar datos de SQL Server. Se crea una

sqlCommand = 'Select * from TableName where posId = 'someId'' 

Éstos son los resultados ...

SQL Server 2008 R2 Reading-1(ms) Reading-2(ms) Reading-3(ms) Average Time in Seconds 
Iteration Count = 5 2528    2649   2665     2.614 
Iteration Count = 10 5280    5445   5343     5.356 
Iteration Count = 15 7978    8370   7800     8.049333333 
Iteration Count = 20 9277    9643   10220    9.713333333 

AppFabric     Reading-1   Reading-2 Reading-3 Average Time in Seconds 
Iteration Count = 5  10301   10160   10186    10.21566667 
Iteration Count = 10  20130   20191   20650    20.32366667 
Iteration Count = 15  30747   30571   30647    30.655 
Iteration Count = 20  40448   40541   40503    40.49733333 

Me estoy perdiendo algo aquí? ¿Por qué es tan lento?

Answer 1

Creo que su prueba es parcial y sus resultados no son óptimos.

Acerca de caché distribuida

• caché local: ha desactivado función local cache. Los objetos de caché siempre se recuperan del servidor; la transferencia de red y la deserialización tienen un costo.
• BulkGet: BulkGet mejora el rendimiento cuando se utiliza con objetos pequeños, por ejemplo, cuando se recuperan muchos objetos de 1 - 5 KB de tamaño o menos.
• Sin compresión de datos: sin compresión entre AppFabric y los clientes de caché. Compruebe this.

acerca de su prueba

Otra cosa importante es que su no está probando la misma cosa: Por un lado se prueba SELECT * y el otro lado y se prueba N PUNTO x GET.

Answer 2

Esto puede deberse a la serialización incorporada de .Net.

. La serialización .Net utiliza la reflexión que a su vez tiene muy bajo rendimiento. Recomiendo examinar el uso del código de serialización escrito personalizado.

Answer 3

La diferencia es la sobrecarga de la red. En su ejemplo de SQL, salta sobre la red una vez y selecciona N filas. En su ejemplo de AppFabric, salta sobre la red PER RECORD en lugar de a granel. Esta es la diferencia. Para probar esto, almacene temporalmente sus registros en AppFabric como una lista y obtenga solo la lista una vez, o use la AppFabric Bulk API para seleccionarlos todos en una sola solicitud; esto debería representar gran parte de la diferencia.