> So I guess two mysteries solved with one patch!
Actually I spoke too soon... the mt2.clj is still giving the
'unexpected' behavior... I am still mystified.
But going to bed now :)
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the
Sorry for the quad-post, but I just noticed:
http://groups.google.com/group/clojure/browse_thread/thread/6ac273446b4a7183
And actually that is what made the big difference in performance (I'd
done a svn update for something unrelated).
So I guess two mysteries solved with one patch!
Boris I sugges
On a hunch I rearranged such that the agents are not recreated for
each run, but instead are reused from a pre-established set:
http://groups.google.com/group/clojure/web/mt2.2.clj
Strangely (from my understanding of agents) this has a significant
impact on the result!!!
threads: 1
"Elapsed tim
> goes up by only %15 for 3 threads... I would expect it to go up by %50
Actually I would expect it to go up by %100
t1t2
t1
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To post to this grou
> There are two pools of threads servicing agent actions. The send pool
> is fixed in size and based on the number of available cores. The send-
> off pool is variable in size and grows as needed to accommodate the
> largest number of simultaneous pending send-off calls that your
> program p
On Jan 15, 2009, at 9:26 AM, bOR_ wrote:
I think I know when to use one and when to use the other, but the
extra clarification doesn't hurt. However, what happens if you get it
wrong? use send where you should have used send-off, and visa versa? I
would like to know what they do differently.
I think I know when to use one and when to use the other, but the
extra clarification doesn't hurt. However, what happens if you get it
wrong? use send where you should have used send-off, and visa versa? I
would like to know what they do differently.
On 15 jan, 13:12, "Stephen C. Gilardi" wrote
On Jan 15, 2009, at 2:57 AM, bOR_ wrote:
That is, if I understand blocking correctly. Currently assuming that
blocking only happens when two things would like to write the same
ref?
Blocking in this case refers to this definition:
http://en.wikipedia.org/wiki/Blocking_(computing)
You should
Hi Timothy, that is indeed what I was surprised about.
I have been reading up on agents (using the forum and the website),
and one thing that I noticed is that rich is very brief on when to use
send vs send-off. I tried figuring out what the difference is by
sourcecode, but it just seems to call
Hi Chris
> What exactly are you trying to measure?
I think what Boris is expecting is that for 4 CPUs, running 1,2,3,4
equal work threads will take the same amount of time.
This is true when he calls loopfib, but not true when he calls
loopmult:
threads: 1
"Elapsed time: 205.458949 msecs"
"Ela
On Wed, Jan 14, 2009 at 6:00 AM, bOR_ wrote:
>
> However, on this 4core machine, the fib behaves as I would expect when
> I scale up the number of threads, while the multiplication barely
> seems to benefit from the 4 cores. The only difference I see between
> the two functions is that the fib is
Hi all.
I am trying to figure out what the effect of the agent-function is on
the efficiency of concurrency. Here is something I do not really
understand. I've a fibonacci function and a simple multiplication,
both are wrapped in their respective dotimes 100k loop.
However, on this 4core machine
12 matches
Mail list logo
