GIL e hyperthreading

[Ernesto Revilla]

Hola,

me ha despertado curiosidad, pero veo difícil bloquear y desbloquear automáticamente el acceso a los atributos o variables de una clase, por la sigiuente razón:
cuando accedemos leemos o accedemos referencias. En este caso, un __setattri__ podría bloquear y desbloquear automáticamente el acceso, pero en muchos casos, es una estructura, como un diccionario o una lista sobre la cual se realizan operaciones. Entiendo que en este caso, la solución podrían ser estructuras que se bloquean o desbloquean automáticamente. Más interesante, sin embargo, me parece marcar, como en Java, que determinados métodos acceden a 'información sensible'. Se fuerza entonces que toda la información sensible sea accedida a através de métodos del objeto, nunca directamente desde fuera (ej. poniendo __ ). Entonces, el call de ese método al empezar obtiene el acceso exclusivo, y cuando termine lo suelta.

Suponiendo que haya:
class MiClase:
    def __init__(self):
        self.__informacionSensible=[]
    def agregarInfoAInformacionSensible(self, masInfo):
        self.__informacionSensible.append(masInfo)
    def consumirInfoDeInformacionSensible(self):
        return self.__informacionSensible.pop()

La metaclase podría hacer entonces:
* agregar un lock a la clase
* renombrar cada uno de esos metodos 'synchronized' poniendo dos __ delante
* crear una funcion que realiza el acquire, despues la llamada a la funcion, y despues release:
def synchronizedMethodCall(self, methodName, *args, **kwargs):
    self.__lock.acquire()
    try:
        res=getattr(self, "__"+methodName)(*args,**kwargs)
    finally:
        self.__lock.release()
    return res

con lo que cada función 'synchronized' será ahora:
    lambda self, *args, **kwargs: self.synchronizedMethodCall(methodName='<nombre del metodo>', *args, **kwargs)

siempre que se desee que todos esos métodos tengan un lock común, de lo contrario podría agregarse un lock a cada método synchronized.

Desde luego, me parecía una interesante extensión a Python. Quizá estaría bien tener algo como los atributos de C# y que la librería vaya implementando poco a poco una serie de esos atributos.

Saludos, Erny



----- Original Message ----- 
From: "Chema Cortes" <py en ch3m4.org>
To: "La lista de python en castellano" <python-es en aditel.org>
Sent: Friday, March 26, 2004 10:05 AM
Subject: Re: [Python-es] GIL e hyperthreading


Hernan Foffani escribió:

> El caso de uso de esa metaclase podría ser algo así:
> 
>   class Cuenta(object):
>       __metaclass__ = autolock
> 
>      def retiro(self, cantidad):
>         if (self.saldo > cantidad):
>             self.saldo -= cantidad
> 
>      retiro.synchronized = True
> 
> No está mal, no?

De aquel artículo recuerdo que hablaba de crear un "wrapper" para los 
atributos, así que supongo que la metaclase empleaba el método 
__getattribute__ para que quedara más "transparente".

> Paso de implementar autolock. Se lo dejo a alguno que le
> apasionen las metaclases y que le interese el desafío...;-)

Es un tema apasionante que habrá que seguir estudiando. Lástima que 
falte tiempo para dedicarse a ello.

Muchas gracias por las explicaciones.



--------------------------------------------------------------------------------


_______________________________________________
Python-es mailing list
Python-es en aditel.org
http://listas.aditel.org/listinfo/python-es


------------ próxima parte ------------
_______________________________________________
Python-es mailing list
Python-es en aditel.org
http://listas.aditel.org/listinfo/python-es