More findings: The reason that the Clojure's original sort is 8 times
slower than sorted-vec2 is only because Clojure uses its own
comparator by default, instead of using Java's default comparator.
Otherwise it's same performance.
;Modified clojure.core.clj sort
(defn sort2
"Returns a sorted sequence of the items in coll. If no comparator is
supplied, uses compare. comparator must
implement java.util.Comparator."
([coll]
(if (seq coll)
(let [a (to-array coll)]
(java.util.Arrays/sort a)
(seq a))
()))
([#^java.util.Comparator comp coll]
(if (seq coll)
(let [a (to-array coll)]
(. java.util.Arrays (sort a comp))
(seq a))
())))
;Modified sort
user=> (time (dotimes[_ 1000](sort2 v)))
"Elapsed time: 3510.047755 msecs"
;Original sort
user=> (time (dotimes[_ 1000](sort v)))
"Elapsed time: 23872.07338 msecs"
;Sorted vec. Returns vector, not sequence
user=> (time (dotimes[_ 1000](sorted-vec2 v)))
"Elapsed time: 3534.578648 msecs"
On Jan 3, 1:54 pm, Gabi <[email protected]> wrote:
> I investigated a little bit more. Seems that (into-array) is slows
> things down because it seqs (un-necessarily?) that vector before
> passing to clojure.lang.RT/seqToTypedArray.
>
> I almost doubled the speed of sorted-vec by using clojure.lang.RT/
> toArray:
>
> (defn sorted-vec2
> [coll]
> (let [arr (clojure.lang.RT/toArray coll)]
> (java.util.Arrays/sort arr)
> (vec arr)))
>
> user=> (time(dotimes [_ 1000] (sorted-vec2 v)))
> "Elapsed time: 3502.369933 msecs"
>
> user=> (time(dotimes [_ 1000] (sorted-vec v)))
> "Elapsed time: 5874.088425 msecs"
>
> On Jan 3, 10:29 am, Gabi <[email protected]> wrote:
>
> > The sorted-vec is ~4 times faster than Clojure's sort (on my humble
> > old machine):
>
> > user=> (def v (vec (take 10000 (repeatedly #(rand-int 100000)))))
> > #'user/v
> > user=> (time(dotimes [_ 1000] (sort v)))
> > "Elapsed time: 23945.682336 msecs"
> > nil
> > user=> (time(dotimes [_ 1000] (sorted-vec v)))
> > "Elapsed time: 6030.585433 msecs"
>
> > BTW we have state here (the native Java array). Is it thread safe ?
>
> > On Jan 2, 11:04 pm, Meikel Brandmeyer <[email protected]> wrote:
>
> > > Hi,
>
> > > Am 02.01.2010 um 20:17 schrieb ianp:
>
> > > >> A bit uglier, but ought to be quite fast.
>
> > > > Doesn't need to be that ugly, this looks OK to me at least:
>
> > > > (defn sorted-vec [coll]
> > > > (doto (into-array coll)
> > > > (java.util.Arrays/sort)
> > > > (vec)))
>
> > > > It'd also be possible to generalise the return type by passing in a fn
> > > > to apply to the sorted array.
>
> > > Unfortunately the above code does not work, because it returns the array
> > > and not the vector.
>
> > > (defn sorted-vec
> > > [coll]
> > > (let [arr (into-array coll)]
> > > (java.util.Array/sort arr)
> > > (vec arr)))
>
> > > How fast is vec on an array? Isn't there a LazilyPersistentVector which
> > > just wraps the array?
>
> > > Sincerely
> > > Meikel
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to [email protected]
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
