Re: Optimizing a simple Common Lisp Gibbs sampler program

Hi Stephan,

Thanks for your reply.

On Thu, 31 May 2012, crimsonf <at> cs.tu-berlin.de wrote:

> Hi Fareen,
>
> the (the double-float ...) tells the compiler that you insist that the
> result is a double-float; though you may lie to the compiler if x assumes
> non-appropriate values for this declaration.
>
> I see in the Stackoverflow thread that you want to declrare x as beaing a
> d-f >= 0.0. If this is the case than you can try:
>
> (declare (type (double-float 0.0 *) x))

If this declaration says that x is a double float which is greater than or 
equal to 0, then that seems like a good way to resolve the problem.

Can you give me a reference for this syntax? Thanks.

> Then you should also be able to remove the (the double-float ...) since
> the compiler should be able to infer that the result can only be a
> double-float. Furthermore you will get automatically a type/range-check
> for the correct values of x.

Oh, the compiler will automatically put in a runtime check that x >= 0? 
Interesting.

Re: Optimizing a simple Common Lisp Gibbs sampler program

On Thu, 31 May 2012, Pierpaolo Bernardi wrote:

> On Thu, May 31, 2012 at 1:59 AM, Faheem Mitha <faheem <at> faheem.info> wrote:
>
>>     (defun gibbs (N thin)
>>       (declare (fixnum N thin))
>>       (declare (optimize (speed 3) (safety 1)))
>
> Using (safety 0) does make any difference?

I tried it, but it does not have a noticeable effect. Also, I've seen 
people recommending against setting safety to 0.

                                                       Regards, Faheem

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

_______________________________________________
Sbcl-help mailing list
Sbcl-help <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-help

Re: Optimizing a simple Common Lisp Gibbs sampler program (redux) with fun GC issues

Hi Faheem,

I'm going to answer just  one of your questions, because it is way past
my bedtime and the rest require some more thinking.

> 4) The compiler is Ok with
> 
>     (declare ((integer 0 536870911) i j))
> 
> (positive fixnum, basically) but not with
> 
>     (declare ((integer 0 most-positive-fixnum) i j))
> 
> though, if I understand this correctly, most-positive-fixnum is just
> the integer 536870911.
> 

If you declare using such constants you need to use the #. reader macro.
So the following should work:

(declare ((integer 0 #.most-positive-fixnum) i j))

see http://www.lispworks.com/documentation/HyperSpec/Body/02_dhf.htm

Kind regards,
Stephan

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 

Re: Optimizing a simple Common Lisp Gibbs sampler program (redux) with fun GC issues

oh yeah and there are way too many declares in your code. The type
analyzer should be able to figure out most of your declareration. E.g.
with just declaring N thin as

(declare ((integer 0 #.most-positive-fixnum) N thin))

you should be able to remove any declares concerning i and j since their
values are depended on N and thin.

Furthermore, I think you try to reduce overall run-time. Have you
already profiled your code to ensure that the FFI are not the main
contributing factor? You're not going to optimize away this overhead
with your type annotations....

Stephan

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

Re: Optimizing a simple Common Lisp Gibbs sampler program (redux) with fun GC issues

W dniu 2012-06-04 23:11, Faheem Mitha pisze:
> Hi,
>
> I got some feedback, and decided to try reworking this exercise using
> an array. I ran into some issues, at least one of which is quite
> worrying. The code is below, and here are the issue, in descending
> order of importance.
>
> 1) I'm having GC problems. If I run this code a number of times, like
>
> Here is the output for (room) for a newly started REPL.
>
> CL-USER> (room)
> Dynamic space usage is: 92,358,952 bytes.
> (...)
>
> Now I run this a bunch of times.
>
> (time (gibbs 10000 1000))
>
> The dynamic space usage keeps climbing, and eventually I get a heap
> error. At that point (room) gives
>
> CL-USER> (room)
> Dynamic space usage is: 1,010,419,640 bytes.
> (...)
>
> Yikes. After I waited a bit, the dynamic space usage did go down a bit,
> but only a little.
>