Unfortunately I think this will just slow things down, since +(Int32,Int32)
converts its arguments to Int64 and returns an Int64 (presumably to avoid
overflow):
julia> code_typed(+, (Int32,Int32))
1-element Array{Any,1}:
:($(Expr(:lambda, {:x,:y}, {{},{{:x,Int32,0},{:y,Int32,0}},{}}, quote #
int.jl, line 16:
return
box(Int64,add_int(box($(Int64),sext_int($(Int64),x::Int32))::Int64,box($(Int64),sext_int($(Int64),y::Int32))::Int64))::Int64
end)))
which means the types of variables that start out as Int32 will be
unstable, since you are adding to them over the course of the loop. I am
not actually sure how to get Julia to do 32-bit addition.
Simon
On Tuesday, January 14, 2014 6:25:20 PM UTC-5, Földes László wrote:
>
> You can force the literals by enclosing them in int32():
>
> p = [int32(0) for i=1:20000]
> result = [int32(0) for i=1:20000]
> k = int32(0)
> n = int32(2)
> while k < int32(20000)
> i = int32(0)
>
>
>
> On Wednesday, January 15, 2014 12:04:23 AM UTC+1, Przemyslaw Szufel wrote:
>>
>> Simon,
>> Thanks!
>> I changed in Cython to
>> def primes_list(int kmax):
>> cdef int k, i
>> cdef long long n
>> cdef long long p[20000]
>> and now I am getting 2.1 seconds - exactly the same time as Julia and
>> Java with longs...
>>
>> Since the computational difference between 64bit longs and 32bit ints is
>> soo high - is there any way to rewrite my toy example to force Julia to do
>> 32 bit int calculations?
>>
>> All best,
>> Przemyslaw Szufel
>>
>>
>> On Tuesday, 14 January 2014 23:55:12 UTC+1, Simon Kornblith wrote:
>>>
>>> In C long is only guaranteed to be at least 32 bits (IIRC it's 64 bits
>>> on 64-bit *nix but 32-bit on 64-bit Windows). long long is guaranteed
>>> to be at least 64 bits (and is 64 bits on all systems I know of).
>>>
>>> Simon
>>>
>>> On Tuesday, January 14, 2014 5:46:04 PM UTC-5, Przemyslaw Szufel wrote:
>>>>
>>>> Simon,
>>>> Thanks for the explanation!
>>>> In Java int is 32 bit as well.
>>>> I have just replaced ints with longs in Java and found out that now I
>>>> get the Java speed also very similar to Julia.
>>>>
>>>> However I tried in Cython:
>>>> def primes_list(int kmax):
>>>> cdef int k, i
>>>> cdef long n
>>>> cdef long p[20000]
>>>> ...
>>>>
>>>> and surprisingly the speed did not change...at first I thought that
>>>> maybe something did not compile or is in cache - but I made sure - it's
>>>> not
>>>> the cache.
>>>> Cython speed remains unchanged regardles using int or long?
>>>> I know that now it becomes other language question...but maybe someone
>>>> can explain?
>>>>
>>>> All best,
>>>> Przemyslaw Szufel
>>>>
>>>>
>>>> On Tuesday, 14 January 2014 23:29:40 UTC+1, Simon Kornblith wrote:
>>>>>
>>>>> With a 64-bit build, Julia integers are 64-bit unless otherwise
>>>>> specified. In C, you use ints, which are 32-bit. Changing them to long
>>>>> long
>>>>> makes the C code perform similarly to the Julia code on my system.
>>>>> Unfortunately, it's hard to operate on 32-bit integers in Julia, since +
>>>>> promotes to 64-bit by default (am I missing something)?
>>>>>
>>>>> Simon
>>>>>
>>>>> On Tuesday, January 14, 2014 4:32:16 PM UTC-5, Przemyslaw Szufel wrote:
>>>>>>
>>>>>> Dear Julia users,
>>>>>>
>>>>>> I am considering using Julia for computational projects.
>>>>>> As a first to get a feeling of the new language a I tried to
>>>>>> benchmark Julia speed against other popular languages.
>>>>>> I used an example code from the Cython tutorial:
>>>>>> http://docs.cython.org/src/tutorial/cython_tutorial.html [ the code
>>>>>> for finding n first prime numbers].
>>>>>>
>>>>>> Rewriting the code in different languages and measuring the times on
>>>>>> my Windows laptop gave me the following results:
>>>>>>
>>>>>> Language | Time in seconds (less=better)
>>>>>>
>>>>>> Python: 65.5
>>>>>> Cython (with MinGW): 0.82
>>>>>> Java : 0.64
>>>>>> Java (with -server option) : 0.64
>>>>>> C (with MinGW): 0.64
>>>>>> Julia (0.2): 2.1
>>>>>> Julia (0.3 nightly build): 2.1
>>>>>>
>>>>>> All the codes for my experiments are attached to this post (Cython i
>>>>>> Python are both being run starting from the prim.py file)
>>>>>>
>>>>>> The thing that worries me is that Julia takes much much longer than
>>>>>> Cython ,,,
>>>>>> I am a beginner to Julia and would like to kindly ask what am I doing
>>>>>> wrong with my code.
>>>>>> I start Julia console and use the command include ("prime.jl") to
>>>>>> execute it.
>>>>>>
>>>>>> This code looks very simple and I think the compiler should be able
>>>>>> to optimise it to at least the speed of Cython?
>>>>>> Maybe I my code has been written in non-Julia style way and the
>>>>>> compiler has problems with it?
>>>>>>
>>>>>> I will be grateful for any answers or comments.
>>>>>>
>>>>>> Best regards,
>>>>>> Przemyslaw Szufel
>>>>>>
>>>>>
