...and, suddenly, the high-core-count Opterons show us what we wanted and
hoped for. If I increase that range statement to 100 and run it on the
48-core node, it takes 50 seconds (before it took 50 minutes), while the
FX-8350 takes 3:31.89 and the 3770K takes 3:48.95. Thanks Marshall! I think
you may have just saved us outrageous quantities of time, though Lee isn't
convinced that we know exactly what's going on with clojush yet, I don't
think. We haven't looked at it yet though.... I'm sure we will soon enough!

On Tue, Dec 11, 2012 at 2:57 PM, Wm. Josiah Erikson <wmjos...@gmail.com>wrote:

> And, interestingly enough, suddenly the AMD FX-8350 beats the Intel Core
> i7 3770K, when before it was very very much not so. So for some reason,
> this bug was tickled more dramatically on AMD multicore processors than on
> Intel ones.
>
>
> On Tue, Dec 11, 2012 at 2:54 PM, Wm. Josiah Erikson <wmjos...@gmail.com>wrote:
>
>> OK WOW. You hit the nail on the head. It's "reverse" being called in a
>> pmap that does it. When I redefine my own version of reverse (I totally
>> cheated and just stole this) like this:
>>
>> (defn reverse-recursively [coll]
>>   (loop [[r & more :as all] (seq coll)
>>          acc '()]
>>     (if all
>>       (recur more (cons r acc))
>>       acc)))
>>
>>
>>
>> I speed it up from, get this, 4:32 to 0:25. Yeah.
>>
>> In case anybody's curious, pmap and pmapall show identical performance in
>> this case.
>>
>> Wow.
>>
>> -Josiah
>>
>>
>> On Tue, Dec 11, 2012 at 1:06 PM, Marshall Bockrath-Vandegrift <
>> llas...@gmail.com> wrote:
>>
>>> Lee Spector <lspec...@hampshire.edu> writes:
>>>
>>> > If the application does lots of "list processing" but does so with a
>>> > mix of Clojure list and sequence manipulation functions, then one
>>> > would have to write private, list/cons-only versions of all of these
>>> > things? That is -- overstating it a bit, to be sure, but perhaps not
>>> > entirely unfairly -- re-implement Clojure's Lisp?
>>>
>>> I just did a quick look over clojure/core.clj, and `reverse` is the only
>>> function which stood out to me as hitting the most pathological case.
>>> Every other `conj` loop over a user-provided datastructure is `conj`ing
>>> into an explicit non-list/`Cons` type.
>>>
>>> So I think if you replace your calls to `reverse` and any `conj` loops
>>> you have in your own code, you should see a perfectly reasonable
>>> speedup.
>>>
>>> -Marshall
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Clojure" group.
>>> To post to this group, send email to clojure@googlegroups.com
>>> Note that posts from new members are moderated - please be patient with
>>> your first post.
>>> To unsubscribe from this group, send email to
>>> clojure+unsubscr...@googlegroups.com
>>> For more options, visit this group at
>>> http://groups.google.com/group/clojure?hl=en
>>>
>>
>>
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to