Das deutsche Python-Forum

Code: Alles auswählen

import pp, scipy

def h(b):
    return scipy.cos(b)**2

def func1(a):
    return scipy.sin(a)**h(b)

job_server = pp.Server()

f1 = job_server.submit(func1, (1,), ('h',), ('scipy',))

Code: Alles auswählen

import pp

class cl(object):
    def __init__(self,a):
        #irgendwelche zahlen
        self.a = a
    
    def int_func(self,x):
        #irgendeine funktion,soll parallelisiert werden
        return x**self.a
    
    def func(self,y):
        #ruft ein paar mal int_func auf,das soll parallel geschehen
        j = pp.Server()
        js = {}
        r=0
        
        #jobs creieren
        for i in xrange(10):
            js[repr(i)] = j.submit(self.int_func, (y,),(),())
        
        #ergebnisse einfordern
        for i in xrange(10):
            print js[repr(i)]()
        
        return r

b = cl(10)
print b.func(4)

Code: Alles auswählen

class MyClass(object):
    ....
    def _heavy_calcs(self, ....): pass
    def modify_object(self, ...):
         ...
         _heavy_calcs(...)

# Objekt anlegen
m = MyClass(....)
...
j.submit(m.modify_object, ...)

Code: Alles auswählen

import pp, scipy.optimize

class cl(object):
    
    def __init__(self,a):
        #irgendwelche zahlen
        self.a = a
    
    def heavy_calc(self,x):
        #irgendeine funktion,soll parallelisiert werden
        
        #in der realitaet werden hier recht grosse numpy-arrays
        #multipliziert und summiert
        #dabei wird glueckicherweise nur auf Attribute der Instanz und nicht
        #auf Methoden zugegriffen (falls das eine Rolle spielt)
        return x**self.a
    
    def multiple_heavy_calcs(self,y):
        #ruft einige male hintereinander int_func auf,
        #das soll parallel geschehen
        
        #in der realitaet wird hier eine Matrix erstellt
        #dazu wird durch die indizes iteriert
        #mein erster ansatz nutzte ausschliesslich numpy-arrays
        #leider wurden die arrays dann sehr gross
        #(ab einer groesse von 64x64x64x64 bekomme ich einen memory error,
        #float64,tatsaechlich haette die groesste matrix 8 dimensionen zu je
        #ca. 64 eintraegen - nach meiner rechnung brauche ich da gar nciht
        #drueber nachdenken dass in einen array zu packen)
        j = pp.Server()
        js = {}
        r=0
        
        #jobs creieren
        for i in xrange(10):
            js[repr(i)] = j.submit(self.heavy_calc, (y,),(),())
        
        #ergebnisse einfordern
        for i in xrange(10):
            #das wollte ich eigentlich machen
            #r += js[repr(i)]()
            
            #um das aber mal zu demonstrieren:
            print js[repr(i)]()
        
        return r
    
    def result(self,x0,x1):
        #diese letzte funktion wird dann tatsaechlich aufgerufen
        
        #in der realitaet wird die nullstelle der determinante der matrix gesucht
        return scipy.optimize.brentq(self.multiple_heavy_calcs, x0,x1)

b = cl(10)
print b.result(0,1000)