Angel "Java" Lopez

NET, Java, PHP y Desarrollo de Software

This Blog

Syndication

Search

Tags

Community

Email Notifications

Archives

.NET

ASP.NET

Windows Form

VB.NET

C#

Sitios

Blogs

AjSharp: Implementando Futures

Había implementado canales en mi intérprete AjSharp. Describí el trabajo y ejemplos en:

Channels and GoRoutines in AjSharp (part 1)
Channels and GoRoutines in AjSharp (part 2)

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

También los usé directamente en C#:

GoRoutines y Canales en C#

Podría usar canales para implementar futures. Una opción es usar Task Parallel Library de Microsoft, pero entonces debería usar .NET 4: aparentemente, la librería original no está más disponible para .NET 3.x. Imagino que podría aprovecharme de las nuevas clases del nuevo framework, pero mientras, quiero explorar las ideas de programación con futures por mi cuenta.

Los canales pueden ser usados para implementar el proceso de futures:

channel = new Channel();
go channel <- SomeLengthlyCalculation();
// .. more process
result = <- channel;

Pero los canales han sido diseñados para resolver otros problemas: para tener varios valores durante su vida, y ser usados como objetos de sincronización entre productores y consumidores de esos valores. La variable channel del ejemplo de arriba, si se usara como un future, podría ser consultada sólo una vez. Es un pequeño problema, pero señala una diferencia entre canales y futures.

Así, escribí una nueva clase nativa, accesible desde programas AjSharp, llamada Future:

    public class Future : IReference
    {
        private object value;
        private ManualResetEvent handle = new ManualResetEvent(false);
        private bool set = false;
        public void SetValue(object value)
        {
            lock (this)
            {
                if (this.set)
                    throw new InvalidOperationException("Future value already calculated");
                set = true;
                this.value = value;
                this.handle.Set();
            }
        }
        public object GetValue()
        {
            this.handle.WaitOne();
            return this.value;
        }
    }

En la versión actual en el trunk, la interface IReference (que contiene méteodos SetValue, GetValue) está implementada por la clase Channel. Los operadores AjSharp a <- b, a = <-b, son mapeados a esos métodos. Entonces podemos usar Futures de esta forma:

future = new Future();
go future <- SomeLenghtlyProcess();
// ... more process
result = <-future;
result2 = <-future;

La consulta del valor del future es explícita, usando el operador <-. De esta forma, podemos pasar la variable future a cualquier otra función, usando el nombre, sin ver todavía su valor. Podría eliminar el go en el seteo de la variable future, asumiendo que el valor a la derecha de ese valor se calcula en paralelo. Pero prefiero hacer que el paralelismo quede explícito, usando el comando go.

Esta es una mejora menor en el procesamiento en paralelo de AjSharp. Estoy trabajando en queue channels: channels que soporten el manejo de más de un valor, sin bloquearse. Pueden ver el código y ejemplos en:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage

Quiero implementar agentes, para soportar la programación basada en el actor model. Podría ser interesante tener a la palabra agent como palabra clave, como la palabra class. Y que esos agentes puedan ser ejecutados en máquinas remotas.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Published Thu, Jan 28 2010 10:57 by lopez

Leave a Comment

(required) 
(required) 
(optional)
(required) 
If you can't read this number refresh your screen
Enter the numbers above: