How to implement a pipeline...??? Please help

Ritchy lelis ritchy_gato at hotmail.com
Wed Aug 11 04:01:41 CEST 2010


On 7 Ago, 07:30, Dennis Lee Bieber <wlfr... at ix.netcom.com> wrote:
> On Fri, 6 Aug 2010 16:47:58 -0700 (PDT), Ritchy lelis
> <ritchy_g... at hotmail.com> declaimed the following in
> gmane.comp.python.general:
>
> > Guys i'm asking if it's possible for a generic function for a
> > pipeline, all the suggestions ideas are welcome.
>
>         I've not done metaclasses, so don't know if a metaclass would be of
> use... Since it appears one would have to have something that generates
> functions on the fly based upon inputs...
>
>         I look at details on what you are trying to create and see a
> series-parallel circuit architecture with clocked stages and delay lines
> for the summing of the outputs. That is, when the clock ticks, every
> stage in the unit does its processing and provides and output... On the
> next tick, those outputs become inputs to the subsequent stage and the
> process repeats
>
> > Also if you have a specific solution for my problem I will be grateful
> > for it here.
>
>         I'm still blinking at the thought of doing analog to digital
> conversion in Python! I sure wouldn't hold out much hope of real-time
> signal processing. There is a reason ADC and DAC are done in hardware,
> even if the intermediate processing is with general purpose processors.
>
>         I'm also not sure I understand the
>
> np.linspace(1,1, Inc)...
>
>         Looking up documentation implies you are trying to create a vector
> of "inc" length, evenly populated by values between 1 and 1... which
> means a vector of all 1s... Might it not be faster to just
>
>         v = [1] * inc
>
> and pass v to some numpy method for conversion from Python list to numpy
> vector?
>
> (the -1 to 1 at least makes sense)
>
>         Me? I'd probably create a class in which the __init__() takes a
> value specifying the number of stages. It would than create suitable
> lists to track values, some sort of counter (c), a Semaphore (s)
> [initialized at 0 -- ie, already acquired/block],  a thread for EACH
> stage, and an Event (e) object
>
>         Each stage thread, initialized with its position in the pipeline.
> The threads perform an e.wait() call. They also, after the wait is
> released, perform an e.clear() call. As their processing, they each grab
> from the pipeline "input" list the current value for their position.
> After processing they update their position in the "output" list(s),
> they decrement the counter c (maybe put a lock around access to c). The
> thread that decrements c to 0 is responsible for "releasing" the
> semaphore.
>
>         The main code of the class instance is responsible for a loop that
> does: set up the "input" list based on current value of stage outputs,
> initialize c to the count of stages (minus 1?), e.set() to signal all
> stage threads to process the current conditions, s.acquire() to block
> until the last processed thread (by c hitting 0) does s.release(). It
> then collects the output lists, does whatever shifting is needed to
> prepare for the next cycle...
>
>         Actually, that "loop" may not be a loop so much as a method off the
> class like
>
>         digitalOutput = adcInstance.step(analogInput)
>
> which is, itself, in a loop.
>
> That is, something like...
>
> myADC = ADC(stages=10)
> while True:
>         voltage = getNextAnalogInput()
>         digital = myADC.step(voltage)
>         outputDigitalValue()
>
>         Obviously I've not taken the time to actually lay out all the
> instance lists needed for inputs and outputs, nor the code of threads
> (while one can create the first "stages-1" threads with a loop, the
> final stage needs a discrete creation)
>
>         When one finds that the threading solution is really slow (though
> understandable in terms of the hardware circuit -- one thread per stage
> makes the stages easy to code), THEN one might try to figure out how to
> implement an iterative version... I suspect using numpy would be the
> third optimization -- removing iteration by using parallel vector
> operations.
> --
>         Wulfraed                 Dennis Lee Bieber         AF6VN
>         wlfr... at ix.netcom.com    HTTP://wlfraed.home.netcom.com/


Hi

First of all i would like to thank you for your time and help.

I appreciate your suggestions and they seems very good to me... The
only problem it's that i'm newbie at python programming, but still
interested to learn more and more...

I already got a solution through harsh but it worked. at least I got
the wave form i wanted.

Next i'm going to let you'll my solution here. It's rudimentary but it
work's.

Seems very perceptible that's why i will not explain it right now but
if in case of doubt I will:

Pipeline Function:

from flash1b5 import flash1b5
from flash1b5 import *
from flash2b import flash2b
from flash2b import *
import matplotlib.pyplot as plt
import numpy as np
from pylab import *

if __name__ == "__main__":

    Inc = raw_input("Valor do Incrimento = ")

    Vref = np.linspace(1,1, Inc)
    Vi = np.linspace(-1,1, Inc)
#    x = np.linspace(-1,1, Inc)
#    Vi = 1*sin(2*pi*(x-1/4))
    Cs = np.linspace(3e-12, 3e-12, Inc)
    Cf = np.linspace(3e-12, 3e-12, Inc)

    f1 = flash1b5(Vi, Vref, Cs, Cf)

    Vin1 = f1[0]
    Vt1 = f1[1]
    Vd1 = f1[2]*256

    f2 = flash1b5(Vt1, Vref, Cs, Cf)

    Vin2 = f2[0]
    Vt2 = f2[1]
    Vd2 = f2[2]*128

    f3 = flash1b5(Vt2, Vref, Cs, Cf)

    Vin3 = f3[0]
    Vt3 = f3[1]
    Vd3 = f3[2]*64

    f4 = flash1b5(Vt3, Vref, Cs, Cf)

    Vin4 = f4[0]
    Vt4 = f4[1]
    Vd4 = f4[2]*32

    f5 = flash1b5(Vt4, Vref, Cs, Cf)

    Vin5 = f5[0]
    Vt5 = f5[1]
    Vd5 = f5[2]*16

    f6 = flash1b5(Vt5, Vref, Cs, Cf)

    Vin6 = f6[0]
    Vt6 = f6[1]
    Vd6 = f6[2]*8

    f7 = flash1b5(Vt6, Vref, Cs, Cf)

    Vin7 = f7[0]
    Vt7 = f7[1]
    Vd7 = f7[2]*4

    f8 = flash1b5(Vt7, Vref, Cs, Cf)

    Vin8 = f8[0]
    Vt8 = f8[1]
    Vd8 = f8[2]*2

    f2b = flash2b(Vt8, Vref)

    Vin2b = f2b[0]
    Vd2b = f2b[1]*1

    Vd = Vd1+Vd2+Vd3+Vd4+Vd5+Vd6+Vd7+Vd8+Vd2b

##    print 'Vin = ',Vin
##    print 'Vt = ',Vt
##    print 'Vd = ',Vd
##
#    fig1 = figure(1,figsize=(8,5))
#    ax1 = fig1.add_subplot(211, autoscale_on=False, xlim=(-1,1),
ylim=(-1,1))
#    ax1.plot(Vin1, Vt4, lw=2, color='blue')
#    grid (True); title('FLASH 1.5 BIT',fontsize =
16);ylabel('Vout_Residuo')
##
##    ax1.annotate('00', xy=(-0.5, 0.5))
##    ax1.annotate('01', xy=(0.0, 0.5))
##    ax1.annotate('11', xy=(0.5, 0.5))
#
##    hold(True)
#
    fig2 = figure(1,figsize=(8,5))
    ax2 = fig2.add_subplot(111, autoscale_on=True)
    ax2.plot(Vin1, Vd, lw=2, color='red')
    grid (True); xlabel('Vin');ylabel('Vout_Digital')
#
##    ax2.annotate('00 --> 0', xy=(-0.5, 0.1))
##    ax2.annotate('01 --> 1', xy=(0.0, 1.1))
##    ax2.annotate('11 --> 2', xy=(0.5, 2.1))
##
#
    plt.show()
--------------------------------------------------------------------------

About the answer i got for my last post:

 1 -
    v = [1] * inc
>
> and pass v to some numpy method for conversion from Python list to numpy
> vector?

Yes i agree with you, but at the time i made it i found that function
(Linspace) that could do what i was loking for and i didn't worry
about search for a better solution. but even if wanted to, i'm new at
the programming language and i don't know how to convert a list to a
vector in numpy. but still open for tips/tricks that could help me.

2 -

>         Me? I'd probably create a class in which the __init__() takes a
> value specifying the number of stages. It would than create suitable
> lists to track values, some sort of counter (c), a Semaphore (s)
> [initialized at 0 -- ie, already acquired/block],  a thread for EACH
> stage, and an Event (e) object

>         Each stage thread, initialized with its position in the pipeline.
> The threads perform an e.wait() call. They also, after the wait is
> released, perform an e.clear() call. As their processing, they each grab
> from the pipeline "input" list the current value for their position.
> After processing they update their position in the "output" list(s),
> they decrement the counter c (maybe put a lock around access to c). The
> thread that decrements c to 0 is responsible for "releasing" the
> semaphore

I did understand your algorithm/idea and that's what i want to
implement here (you couldn't be more right). but i don't now how to
implement the funcs e.wait() call and e.clear() call. they already
exists? i have to create them?

if I may, i would like to ask more help on this one please. I hope not
to be bothering you :(



More information about the Python-list mailing list