I have moved this website here ( Jorge Niedbalski, website )

Es un elemento crucial para cualquier aplicación que obtenga informacion de un centro de computo que tome tiempo en procesar una solicitud , lo anterior debido a que que se deben inicializar estructuras para mantener las copias de datos/buffers/ , generalmente inicializar un descriptor , sobre eso realizar la lógica del protocolo , solicitar el recurso, inicializar la transferencia y finalmente copiar en las estructuras previamente allocadas.

La solución mas simple es realizar una sola vez este proceso durante un periodo T , manteniendo esta información en algun backend accesible por el proceso sin necesidad de realizar nuevamente el costoso proceso descrito anteriormente de forma transparente para la aplicación.

Como :

Si los datos solicitados se encuentran en el cache ( hit ) , la solicitud será atendida leyendolo desde el caché, lo que acelerará el tiempo de respuesta. En el caso de que el dato solicitado no se encuentre, será solicitado a la fuente de datos en su ubicación original ( independiente del protocolo ) y almacenada en el caché intermedio. Del mismo modo, la siguiente solicitud para el mismo recurso será atendida desde el caché previamente almacenado.

Cache Manager Design Pattern

Código:

La implementación utiliza adicionalmente un patrón Factory para obtener una instancia dependiendo del tipo de backend seleccionado , tambien utiliza un patrón singleton en vista de asegurar la existencia de una sola instancia en un ciclo de ejecucción.

<?php

/*
* Partial implementation of a Cache Manager Pattern for general use.
*
* @author Jorge Niedbalski R.
* @(#)Data::Cache::CacheManager
*
*/

class   CacheObjectException extends Exception {}
class   CacheObject {

    private    $is_url;
    private $keyname;
    private $lifetime;
    private $value;
    private $backend;

    public  function    __construct($backend = NULL, $keyname, $value, $lifetime, $is_url = FALSE)
    {
                $this->backend  = $backend;
                $this->keyname  = $keyname;
                $this->value    = $value;
                $this->lifetime = $lifetime;
                $this->is_url   = TRUE;
        }

        public  function    __destruct()  {}

        public  function getKeyName()
        {
            return ( $this->keyname );
        }   

        public  function    getLifeTime()
        {
            return ( $this->lifetime );
        }

        public  function    getValue()
        {
            if($this->is_url) {
                $this->value = file_get_contents($this->keyname);
                if($http_response_header[0] != 'HTTP/1.1 200 OK') {
                    throw new CacheObjectException(sprintf("Invalid response from resource %s", $this->keyname));
                }
            }
            return ( $this->value );
        }

        public  function    getBackend()
        {
            return ( $this->backend );
        }

        public    function    isURL()
        {
            return    ( $this->is_url );
        }

        public  function    setBackend($backend)
        {
            $this->backend = $backend;
        }

        public  function    setKeyName($name, $url = FALSE)
        {
            $this->keyname = $name;
        }

        public    function    setIsURL($is_url = FALSE)
        {
            $this->is_url = $is_url;
        }

        public  function    setLifeTime($lifetime)
        {
            $this->lifetime = $lifetime;
        }

        public  function    setValue($value)
        {
            $this->value    = $value;
        }

        public  function    fetch()
        {
            try {
                return ( CacheManager::fetchObject($this) );
            } catch(CacheManagerException $e) {
                throw new CacheObjectException($e->getMessage());
            }
        }
    }

    class   CacheBackendFactoryException extends Exception {}
    class   CacheBackendFactory
    {
       protected static $_instance; //single instance for each backend on the same execution time

       public   static  function    getInstance($backend)
       {
            if(self::$_instance == NULL) {
                $backend_class = sprintf("%sBackend", $backend);
                $backend_file  = sprintf("%s/Backends/%s.php", dirname(__FILE__), $backend_class);

                if(!file_exists($backend_file)) {
                    throw new CacheBackendFactoryException(sprintf("File %s not found on available backend classes\n", $backend_file));
                }

                require_once($backend_file);
                self::$_instance = new $backend_class();
            }

            return ( self::$_instance );
        }
    }

    class   CacheException extends Exception {}
    class   Cache {

         public static  function    fetchObject(CacheObject $object)
         {
            try {
                    return ( CacheBackendFactory::getInstance($object->getBackend())->fetchObject($object) );
            } catch(CacheBackendFactoryException $e) {
                throw new CacheException($e->getMessage());
            } catch(CacheBackendException $e) {
                throw new CacheException($e->getMessage());
            }
         }

         public static  function    addObject(CacheObject $object)
         {
            try  {
                    return ( CacheBackendFactory::getInstance($object->getBackend())->saveObject($object) );
            } catch(CacheBackendFactoryException $e) {
                throw new CacheException($e->getMessage());
            } catch(CacheBackendException $e) {
                throw new CacheException($e->getMessage());
            }
         }
    }

    class   CacheManagerException extends Exception {}
    class   CacheManager {

        public static   function    fetchObject(CacheObject $object)
        {
            try {
                return ( Cache::fetchObject($object) );
            } catch(CacheException $e) {
                throw new CacheManagerException($e->getMessage());
            } catch(ObjectKeyNotFoundException $e) {
                try {
                    return ( Cache::addObject($object) );
                } catch(ObjectCreaterException $e) {
                    throw new CacheManagerException($e->getMessage());
                } catch(CacheException $e) {
                    throw new CacheManagerExeption($e->getMessage());
                }
            }
        }
    }

    interface   Interface_CacheBackend {
        public  function    fetchObject(CacheObject $object);
        public  function    saveObject(CacheObject $object);
    }
?>

Una implementación de Backend , ha sido realizada utilizando Memcached como centro de almacenamiento en un esquema llave-valor (debes tener instalada la extensión Pecl Memcache ) :

<?php

define(MEMCACHE_HOST, '127.0.0.1');
define(MEMCACHE_PORT, 11211);

class	ObjectKeyNotFoundException extends Exception {}
class	CacheBackendException	extends Exception {}

class	MemcacheBackend implements Interface_CacheBackend {

		private	$conn;

		public	function	__construct()
		{
			$this->conn = new Memcache();
			$this->conn->connect(MEMCACHE_HOST, MEMCACHE_PORT);
		}

		public	function	fetchObject(CacheObject $object)
		{
			if( ($data = $this->conn->get($object->getKeyName()) ) == FALSE ) {
				throw new ObjectKeyNotFoundException();
			} else {
				return ( $data );
			}
		}

		public	function	saveObject(CacheObject $object)
		{
			if ( $this->conn->set($object->getKeyName(), $object->getValue(), 0, $object->getLifeTime()) ) {
				return ( $object->getValue() );
			}

			throw new CacheBackendException("Cannot save cache key %s", $object->getKeyName());
		}

}

?>

Otros

Es un patrón de uso cotidiano para cualquier programador que se interese en el rendimiento de su aplicación. Es importante que sea usado con un backend que asegure un buen tiempo de respuesta.

Referencias

Caché
Pecl Memcache

Se utiliza cuando se tiene una arquitectura del tipo un productor a varios consumidores ( cliente-servidor ) , es la primitiva mas esencial del paso de mensajes, acoplamiento en una dirección y accionamiento jerarquico para un modelo de eventos.

Como

Código

En este caso utilizaremos la capa de abstracción de streams de PHP5 para desplegar un ejemplo de la implementación de este patrón.

<?php
/**
* PHP5 Observer pattern
*
* @author Jorge Niedbalski R.
* @(#)Data::Observer
*
**/
define('DEFAULT_SOCKET_TIMEOUT', 30);

class   SubjectException extends Exception {}
class   Subject {

    private $observerCollection = array();

    public  function    registerObserver(Observer $observer)
    {
        $object_hash = spl_object_hash($observer);

        if(array_key_exists($object_hash, $this->observerCollection) == TRUE) {
            throw new SubjectException("Object %s already exists\n", $object_hash);
        }

        $this->observerCollection[$object_hash] = $observer;
        return ( TRUE );
    }

    public  function    unregisterObserver(Observer $observer)
    {
         unset($this->observerCollection[spl_object_hash($observer)]);
    }

    public  function    notifyObservers($message)
    {
        foreach($this->observerCollection as $key => $registered_observer) {
            $registered_observer->notify($message);

        }
    }

}

class  Observer {
    public  function    notify($message) {
        $context = stream_context_create(array(
            'http' => array(
                            'method' => 'POST',
                            'header' => sprintf("Authorization: Basic %s\r\nContent-type: application/x-www-form-urlencoded\r\n", base64_encode(sprintf("%s:%s", $this->username, $this->password))),
                            'content'=> http_build_query(array('status' => $message)),
                            'timeout'=> DEFAULT_SOCKET_TIMEOUT,
                      ),
            )
        ); 

        file_get_contents($this->endpoint, FALSE,$context);
    }
}

class   TwitterObserver  extends Observer {
        public  function    __construct() {
            $this->endpoint = "http://twitter.com/statuses/update.xml";
            $this->username = "ikslabdein";
            $this->password = "foobar";
        }
}

class   OtherObserver extends Observer {
        public  function    __construct() {
            $this->endpoint = "http://other.service.com/update.xml";
            $this->username = "foobar";
            $this->password = "bafoor";
        }

}

$subject  = new Subject();

$subject->registerObserver(new TwitterObserver());
$subject->notifyObservers("I am Testing observer pattern, yeah !@#");

?>

Otros

El ejemplo describe un patrón de observer en PHP5 para hacer POST via HTTP de un dato a multiples destinos. Puede ser ampliable a multiples stream asincronos o a algún otro protocolo implementado como stream wrapper..

Referencias
Wikipedia- Observer Pattern

Para un valor dado t se utiliza una funcion m tal que m genere una llave k que represente un indice en un vector o un slot de un array asociativo.

Dadas las limitaciones como espacio de direcciones disponibles en una computadora digital , es teoricamente imposible que para cada valor t de un conjunto potencialmente infinito , no existan colisiones para el mismo indice en el mismo slot.

Debido a este axioma la gran mayoria de los algoritmos que implementan tabla hash asumen la paradoja del cumpleaños implicando que a medida que aumentan los indices en la tabla. independiente de la uniformidad de la función de dispersión , la probabilidad de colisión aumenta linealmente.

Es por lo antes expuesto que es un requerimiento escencial para la funcion de dispersion proveer una distribución uniforme que garantice una baja cantidad de colisiones y un costo cercano a lineal para la resolución. Mas adelante iré describiendo algunas tecnicas para la resolución de colisiones en una tabla hash ( algunas estudiadas durante mi tesis de pregrado ).

Lo importante es que conozcamos al menos una función que distribuya valores no conocidos de tamaño-no acordado ( variable ) . Para el caso de valores conocidos es posible crear una tabla hash perfecta ( todos sus valores se distribuyen sin colisiones ) matematicamente es definida como injectiva.

Si cada elemento de entrada puede ocurrir con una probabilidad uniforme , como por ejemplo suponiendo que cada elemento del conjunto de entrada es un integro en el rango de 0 hasta N -1 , una buena funcion hash puede ser h = integro % n.

Para el caso de strings de tamaño variable , existen diferentes funciones para generar llaves que distribuyen relativamente bien en arquitecturas de 32 o 64 bits. La que utilizo con mayor frecuencia es la popular DJBX33X , propuesta por Daniel J. Bernstein . Tambien pueden guiarse por otras funciones de acuerdo a esta comparativa.

La funcion DJBX33X tiene algunas caracterizticas que la hacen única, en primer lugar por que se calcula muy rapido en procesadores i386 y en segundo lugar por que distribuye muy cercano a perfecto.

hash(i) = hash(i-1) * 33 + string[i]

Las razones de por que se escoge el numero 33 como constante son explicadas por Ralf S. Engelschall , sabiendo que este fue escogido como la función hash de PHP ( No es menor , comprendiendo que PHP basa sus GST y otras funcionalidades del lenguaje en tablas de dispersion).

Si experimentalmente se prueban todos los multiplos entre 1 y 256 se detectan que no todos los numeros pares funcionan bien, a diferencia los numeros impares funcionan igual o mejor. En particular el numero 33 no tiene nada de especial por sobre otros buenos numeros con excepcion de que su operacion de multiplicacón puede ser reemplazada por un solo desplazamiento más una operacion de suma o resta.

Ejemplo de implementación utilizando un desplazamiento y suma , con una variante para performance ( repitiendo 8 veces ) :

djbx33a(
    register act_uint8_t *key,
    register act_size_t len)
{
    register act_uint32_t hash = 5381;

#ifdef ACT_NON_OPTIMIZE
    while (len-- > 0)
        hash = ((hash << 5) + hash) + *key++;
#else
    /* variant with the hash unrolled eight times */
    for (; len >= 8; len -= 8 ) {
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
        hash = ((hash << 5) + hash) + *key++;
    }
    switch (len) {
        case 7: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 6: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 5: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 4: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 3: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 2: hash = ((hash << 5) + hash) + *key++; /* fallthrough... */
        case 1: hash = ((hash << 5) + hash) + *key++; break;
        default: /* case 0: */ break;
    }
#endif
    return hash;
}

Tambien puede utilizarse una variante usando un XOR

 hash = ((hash << 5) + hash) ^ *key++;

Tambien es posible utilizar algoritmos de checksum o criptograficos como funciones de dispersión, generalmente producen valores con una distribucion lo suficientemente uniformes , en particular SHA-1 garantiza una uniformidad fuerte , para aplicaciones comunes la desventaja de utilizarlo es el costo del tiempo de calculo.

A modo de conclusión existen multiples funciones de generacion de llaves de dispersión, lo importante es que cumplan con proveer una distribucion uniforme para un set de datos dado. Es importante , además, que sean eficientes en funcion de tiempo, esperando un tiempo lineal. Es posible utilizar funciones criptograficas o de checksum ( no use CRC32 ).

Una formula para calcular la probabilidad de una colisión, puede ser :

Hash collision formula

Por ejemplo 80M de llaves @ 16 KB ( 12.2 TB) tiene una probabilidad de 2.18e-31 de una colisión.

Recordarles que cuando se implementa un algoritmo de tabla hash es importante proveer un buen mecanismo de solución a colisiones, tema que abordare en otro articulo.