n Prozesse starten - Computer Language Shootout

Hallo zusammen

Der gestern erw=E4hnte Test kurz genauer beschrieben

----------------------------------------schnipp-------------

For this test, each program should be implemented to do the same thing.

This test measures the speed of process (or thread) instantiation.
In theory, a CO (Concurrency Oriented) language will have superior
performance in this test. Let's see if our theory holds up!

After the process is created, it should wait on/for an event of some kind.
The actual event does not matter -- it could be a condition variable, a=20
semaphore,
an e-mail, whatever. The important thing is that it is an individual=20
event, so that this
particular process can be told to continue its execution without=20
disturbing the
other processes in this test.

The test program should take one argument, N, which is the number
of processes to create.

The correct output, after all processes have been created, is N.

-----------------------------und durch Babelfish gejagt-----------------

F=FCr diesen Test sollte jedes Programm implementiert werden, um die glei=
che
Sache zu tun. Dieser Test mi=DFt die Geschwindigkeit der=20
Proze=DF-Instantiation.
In der Theorie hat eine Co (die Parallelit=E4t orientiert)-Sprache =FCber=
legene
Leistung in diesem Test. La=DF uns sehen, ob unsere Theorie h=E4lt! Nachd=
em der
Proze=DF verursacht ist, sollte er warten auf einen Fall irgendeiner Art.=
 Der
tats=E4chliche Fall macht nicht aus -- es k=F6nnte eine Bedingungvariable=
, ein
Semaphor, eine E-mail sein, was auch immer. Die wichtige Sache ist, da=DF=
 es
ein einzelner Fall ist, damit diesem bestimmten Proze=DF erkl=E4rt werden=
 kann,
seine Durchf=FChrung fortzusetzen, ohne die anderen Prozesse in diesem Te=
st
zu st=F6ren. Das Testprogramm sollte ein Argument, N nehmen, das die Zahl
der zu verursachenden Prozesse ist. Der korrekte Ausgang, nachdem alle
Prozesse verursacht worden sind, ist N.

--------------------------------schnapp----------------------------------=
----------

Bis auf ein paar Nachbesserungen sind diese Babelfish-=DCbersetzungen
verflucht gut. Was ich mir als m=F6gliche L=F6sung vorstelle w=E4re folge=
ndes

-------------------------------------------------------------------------=
----------

threads =3D []

# Anzahl der Threads als Argument

n =3D ARGV[0].to_i

# Condition variable

check =3D 0

for t in 1..n
  threads << Thread.new(t) { |my_t|
    puts "Running " + my_t.to_s
    loop do
      break if my_t =3D=3D check
    end
    puts "Finishing " + my_t.to_s
  }
end

# Beende zuf=E4llig gew=E4hlte Threads

loop {

    # ohne die 0
  check =3D rand(n+1)

    # einer l=E4uft immer
  break if Thread.list.length =3D=3D 1
}

puts "All threads finished"

-------------------------------------------------------------------------=
--------

Nat=FCrlich sollte man f=FCr den Benchmark die Kommentare und
puts-Anweisungen herausnehmen. Es reicht, zur Demonstration
lediglich einen Thread zu beenden.

Bis die Tage
Enno

PS: Hat schon mal einer mit SOAP herumgespielt?? Ich h=E4tte gern einen=20
Server, der
auf allen Rechnern im Netz meine TODO-Listen abgleicht. Ist zwar mit=20
Kanonen auf
Spatzen geschossen, aber mir f=E4llt nichts anderes ein um mich dem Thema=
=20
Web-Services
zu n=E4hern :)