date:20090708

Re: Does anyone need any clojure work done?

2009-07-08 Thread fft1976


On Jul 7, 10:18 pm, ataggart alex.tagg...@gmail.com wrote:
 After having spent the last decade doing server-side java, lots of
 infrastructure level code which I enjoy), and going blind on xml, I'd
 really like to get more into clojure.

 I've been playing with it off and on for about a year now, reading
 whatever FP-related material I can get my hands on, but without a real
 project to work on it's all been a bit aimless.  To get more serious
 about it I'd need to work on an actual problem to solve.

 To that end, if anyone has a project they'd like help on, be it open
 or closed, paid or not, please let me know.

Talk to Jon Harrop. He just asked for help with his ray tracer. Also
all the shootout needs porting to Clojure. Beware the frequently bad
tempered admin though.
--~--~-~--~~~---~--~~
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
-~--~~~~--~~--~--~---

Re: Passing primitives from an inner loop to an outer loop efficiently

2009-07-08 Thread Jonathan Smith




On Jul 7, 5:10 pm, John Harrop jharrop...@gmail.com wrote:
 Problem: Passing primitives from an inner loop to an outer loop efficiently.
 Here is what I've found.

 The fastest method of result batching, amazingly, is to pass out a list and:

 (let [foo (loop ... )
 x (double (first foo))
 r1 (rest foo)
 y (double (first r1))
 r2 (rest r1)
 z (double (first r2))] ... )


This isn't suprising if you think about it.
In the list situation you are just grabbing the next pointer,
in an array situation you have to do math to access a vector.


 (here passing out three doubles).

 About half as fast is:

 (let [[x y z] (loop ... )] ... ) with (double x), (double y), and (double z)
 used later in place of x y z and only one occurrence of each (so no more
 (double foo) conversions than before). The destructuring bind apparently
 exerts a higher run-time overhead compared to manual destructuring.

If you look at the source code this isn't that surprising.
The big difference between (for example):
(let [[x y z] [1 2 3]] ...) and
(let [v [1 2 3] x (v 0) y (v 1) z (v 2)] ...)

Most of the slowdown Seems to have to do with bounds checking:
The first is 'safe' and returns nil for out of bounds, the second
throws an exception.

but
If you look at the source the 2ary version of nth gets inlined and the
3ary version (which destructuring bind expands to) does not.

and
if you put a symbol in the second position you'll note that
Destructuring bind rebinds the symbol with a Gensym even though it
cannot suffer from multiple evaluation.

If you look here:
http://gnuvince.wordpress.com/2009/05/11/clojure-performance-tips/
And look at 'avoid destructuring binding for vectors'

I did some hacking and improved the worst case from about 500ms on my
computer to 300ms.

(By inlining the 3ary version and removing the duplication; compiling
a destructuring function without bounds checking breaks compilation
for obvious reasons...). There are probably better ways to optimize it
as this was just me screwing around ('What can i break this
evening?').

I will note that there is something very funny going on with the
destructuring/binding example in the link above. The fast version on
my machine returns every number of times(1e7 1e8 1e9 etc...) returns
26 ms. It is kind of like it all just got collapsed into a constant.
--~--~-~--~~~---~--~~
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
-~--~~~~--~~--~--~---

Re: Passing primitives from an inner loop to an outer loop efficiently

2009-07-08 Thread Frantisek Sodomka


If result is a vector v, then from these 4 cases:
(let [v [1 2 3]]
  (let [[a b c] v] a b c)
  (let [a (v 0) b (v 1) c (v 2)] a b c)
  (let [a (nth v 0) b (nth v 1) c (nth v 2)] a b c)
  (let [x (first v) r1 (rest v) y (first r1) r2 (rest r1) z (first
r2)] x y z))

using 'nth'
(let [a (nth v 0) b (nth v 1) c (nth v 2)] a b c)
is the fastest.

Frantisek

On Jul 7, 11:10 pm, John Harrop jharrop...@gmail.com wrote:
 Problem: Passing primitives from an inner loop to an outer loop efficiently.
 Here is what I've found.

 The fastest method of result batching, amazingly, is to pass out a list and:

 (let [foo (loop ... )
 x (double (first foo))
 r1 (rest foo)
 y (double (first r1))
 r2 (rest r1)
 z (double (first r2))] ... )

 (here passing out three doubles).

 About half as fast is:

 (let [[x y z] (loop ... )] ... ) with (double x), (double y), and (double z)
 used later in place of x y z and only one occurrence of each (so no more
 (double foo) conversions than before). The destructuring bind apparently
 exerts a higher run-time overhead compared to manual destructuring.

 (with-locals [x (double 0) y (double 0) z (double 0)]
 (loop ... )
 (do-something-with (double (var-get x)) (double (var-get y)) (double
 (var-get z

 is two full orders of magnitude slower (here the loop doesn't return a list
 but uses var-set).

 Using atoms is even worse.

 (let [#^doubles xyz (double-array (int 3))]
 (loop ... )
 (do-something-with (aget xyz (int 0)) (aget xyz (int 1)) (aget xyz (int
 2

 with the loop using aset-double to pass out values is, surprisingly, no
 faster. Using plain aset makes no difference, as does removing the (int ...)
 wrappings around the numbers.

 Intermediate in speed is using a clojure vector to pass out values, e.g.
 [result-x result-y result-z] is the expression that returns a value from the
 loop, and

 (do-something-with (get results (int 0)) (get results (int 1)) (get
 results (int 2)))

 It's surprising that this is faster than using a primitive Java array with
 type-hints, and interesting that retrieving sequential items from a list is
 faster than a like number of in-order indexed retrievals from a vector,
 which could theoretically be optimized to a pointer-walk with each retrieval
 involving an increment and a dereference and a store, rather than an
 increment, three dereferences, and a store. (Dereference linked list entry
 item pointer, store, increment pointer, dereference to get next-entry
 pointer, dereference again, repeat.)

 Whatever, these results may be useful to someone, along with:

 (defn- extract-result-list-into [conv hint gensyms result-generator] (let
 [rs (take (count gensyms) (repeatedly gensym))] (into [(first rs)
 result-generator] (loop [r rs g (if hint (map #(with-meta % {:tag hint})
 gensyms) gensyms) output []] (if (empty? r) output (let [fr (first r) rr
 (rest r) frr (first rr)] (recur (rest r) (rest g) (into output (concat
 [(first g) (if conv `(~conv (first ~fr)) `(first ~fr))] (if frr [frr `(rest
 ~fr)]))

 This helper function can be used in a macro to suck the contents of a list
 into variables with conversions, type hints, or both; conv would be a symbol
 like `double, hint something like BigInteger, gensyms some gensyms (or other
 symbols) for the variable names (in order), and result-generator some code
 (e.g. resulting from a backtick expression). The output is a vector
 resembling
 [G__5877 (loop ... whatever code)
 #^hint G__5874 (conv (first G__5877))
 G_5878 (rest G__5877)
 #^hint G__5875 (conv (first G__5878))
 G_5879 (rest G__5878)
 #^hint G__5876 (conv (first G__5879))]
 which can be used in a let, loop, or other construct that uses bindings with
 the usual clojure syntax, and can even have other things added to it by
 macro code.

 The downside is relative inflexibility. If you pass in a gensyms seq with an
 embedded vector of two gensyms you'll get a valid destructuring bind for a
 composite item in the results, but it won't work with type hints or
 conversions, nor can those be mixed. Making it more sophisticated would be
 possible, though.

 This arose when I had a performance-critical double-barreled loop to
 optimize, and found that the outer loop was spending several thousand
 iterations of the inner loop worth of time just to extract the results via
 with-locals. I did some experimenting and benchmarking of various ways to
 get the output of the inner loop to code in the outer loop, using
 System/nanoTime, millions of repetitions, and averaging to determine the
 winner.

 An efficient labeled recur would be nice for clojure 2.0. :) (Limited
 though it would be to when the inner loop was in tail position in the outer
 loop.)
--~--~-~--~~~---~--~~
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

Save current namespace like a Smalltalk image

2009-07-08 Thread Robert Campbell


Hello,

Sometimes I have pretty long REPL sessions where I'm trying to flesh
out some ideas. When I close my instance of Clojure Box (Emacs based)
I lose all the definitions I had worked out over time. Is there any
way to dump namespace(s) to an image? It would be great to be able to
load up some workspace image and pick up where I left off.

Rob

--~--~-~--~~~---~--~~
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
-~--~~~~--~~--~--~---

Re: Save current namespace like a Smalltalk image

2009-07-08 Thread Daniel Lyons

Robert,

On Jul 8, 2009, at 2:13 AM, Robert Campbell wrote:

Sometimes I have pretty long REPL sessions where I'm trying to flesh
out some ideas. When I close my instance of Clojure Box (Emacs based)
I lose all the definitions I had worked out over time. Is there any
way to dump namespace(s) to an image? It would be great to be able to
load up some workspace image and pick up where I left off.

Something similar was discussed recently but didn't come to a solid
conclusion:
http://groups.google.com/group/clojure/browse_thread/thread/4efaee2e67a272c6/f24578bfa06e6b9c?lnk=gstq=printing+and+reading+a+function#f24578bfa06e6b9c

This is kind of a cop-out, but in general my advice would be to work
from a file. Get your Clojure and Emacs set up so that you can compile
your stuff pretty easily and your files are in the namespace-
appropriate folder underneath your classpath. For example, I keep my
Clojure code in ~/Projects/Languages/Clojure and my Emacs config looks
like this:

(setq swank-clojure-extra-classpaths
(cons /Users/fusion/Projects/Languages/Clojure/classes
(cons /Users/fusion/Projects/Languages/Clojure
(directory-files ~/.clojure t \.jar$
(eval-after-load 'clojure-mode '(clojure-slime-config))
(setq swank-clojure-extra-vm-args '(-Dclojure.compile.path=/Users/
fusion/Projects/Languages/Clojure/classes))

Now if I want to load or compile a Clojure file, it just works.

Next, when I start doodling I make a file in the aforementioned
directory and put my stuff in there and open up a slime session in
another window. C-c C-c sends the current form over Slime to the
running session. Then I do my interactive testing and exploration in
the slime session. Whenever I hit on a form I want to keep, I copy and
paste it over to the file and make it into a function over there. I
might make a function with a dumb name like demo or test and put a
bunch of forms in there, and eventually they get refactored into unit
tests (or not). If I close Emacs and reopen it on a file that doesn't
yet have a namespace and whatnot, I select the stuff I want to
evaluate and do C-c C-r to evaluate the region. It's handy, if less
transparent.

The main advantage to this, apart from keeping the code clean, is that
you avoid the dirty image problem that can happen with Common Lisp or
(I assume) Smalltalk, where the code seems to work but accidentally
depends on cruft in the image that never made it into the source file.
I've had this happen in CL and found it very frustrating. I had a
tumblog which I tried to make faster by saving images and found one
day to my surprise that I couldn't make a fresh image on my server,
which was running a different architecture, because the only reason it
was able to make images on my box was because the first image had some
crap in it that never made it to the source file. Maybe this problem
isn't as prevalent in Smalltalk; maybe the JVM can circumvent this by
being cross-platform, but it's happened more than once in CL. IIRC,
CMU CL for a long time was self-hosting to such a degree it couldn't
be built at all without a running binary of a previous version. That
kind of thing makes porting to new architectures quite difficult.

Just my $0.02,

—
Daniel Lyons

--~--~-~--~~~---~--~~
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
-~--~~~~--~~--~--~---

Re: Save current namespace like a Smalltalk image

2009-07-08 Thread Robert Campbell

Thanks Daniel, that makes perfect sense, especially about having
random - and forgotten - code in the image. I have a lot of this
during my exploration sessions.

The main reason this is an issue for me is during development I
sometimes find I need another library added to my classpath. Right now
the only way I know how to modify the classpath in Emacs is to change
the .emacs file with an add-to-list 'swank-clojure-extra-classpaths
and reboot. I think my looking for an image solution might be a
cop-out itself; I need to learn Emacs better so I can figure out how
to modify the classpath without rebooting. Then I wouldn't be
rebooting so often and I wouldn't need to be making images to save
I'm-in-the-middle-of-a-thought state

94 matches

Mail list logo