bhuztez (bhuztez) · 回帖

咨询一下这个怎么建模 at 2013年07月25日

#12 楼 @fenprace 纯 Prolog 的语义左递归就死循环了。当然这里没用到也没这个问题。所以现在不得不去看 datalog 语义是怎么实现的

[欧洲] Chinese speaker Ruby/JS/Web Developer - 招聘已结束 at 2013年07月25日

咨询一下这个怎么建模 at 2013年07月25日

#10 楼 @ShiningRay 只填最后一级就好了啊，别的都能从配置里查出来的啊

咨询一下这个怎么建模 at 2013年07月24日

#5 楼 @ShiningRay 数量小，而且基本不会变的数据，没必要用数据库吧。直接从配置文件中载入就够了啊。

state_of_county("Monroe", "New York").
state_of_county("Suffolk", "Massachusetts").
county_of_city("Rochester", "Monroe").
county_of_city("Boston", "Suffolk").

state_of_city(City, State) :-
  state_of_county(County, State),
  county_of_city(City, County).

咨询一下这个怎么建模 at 2013年07月24日

#2 楼 @ShiningRay 反正数据量小啊，不用数据库也可以嘛

咨询一下这个怎么建模 at 2013年07月24日

直接硬编码到配置文件吧...

[欧洲] Chinese speaker Ruby/JS/Web Developer - 招聘已结束 at 2013年07月24日

#22 楼 @blacktulip Google Maps 上找到了

~~http://goo.gl/maps/njBhx~~

[欧洲] Chinese speaker Ruby/JS/Web Developer - 招聘已结束 at 2013年07月24日

#19 楼 @blacktulip 目测不是 UK 本土啊

求推荐颜色或计算公式 at 2013年07月24日

#17 楼 @chairy11 apt-get install ...

开源的 Open Source PaaS，Flynn，正在从社区筹募资金。号称小 Heroku. at 2013年07月24日

#11 楼 @goinaction 没仔细用过 CloudFoundry ... 反正 Openshift 的 DIY 挺方便的，就一直折腾 OpenShift 了

求推荐颜色或计算公式 at 2013年07月24日

#15 楼 @chairy11

可以试试

gpick

https://code.google.com/p/gpick/

KColorEdit

http://extragear.kde.org/apps/kcoloredit/

[欧洲] Chinese speaker Ruby/JS/Web Developer - 招聘已结束 at 2013年07月24日

地点？

[上海] "英语流利说"诚聘 Rails 开发工程师 at 2013年07月24日

人好多啊

[欧洲] Chinese speaker Ruby/JS/Web Developer - 招聘已结束 at 2013年07月24日

没看见有要求 Chinese speaker?

税前英镑 35K-43K 一年

开源的 Open Source PaaS，Flynn，正在从社区筹募资金。号称小 Heroku. at 2013年07月24日

#6 楼 @goinaction 一开始 CloudFoundry 只能用它支持的语言，即便现在也是要通过自定义 buildpack 的方式，OpenShift 很早就有 DIY 类型啊

开源的 Open Source PaaS，Flynn，正在从社区筹募资金。号称小 Heroku. at 2013年07月24日

我喜欢 OpenShift 咋办...

制作 Slides 的错误示范 at 2013年07月24日

Emacs 挺好的啊，Erlang 官方就只提供 emacs mode

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月24日

#45 楼 @luikore 不是寄存器机的语义啊，我说的是 lua 函数调用的语义啊 ...

求推荐颜色或计算公式 at 2013年07月24日

#8 楼 @nightire 求能排除不合理搭配的公式...

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月24日

#43 楼 @luikore 语义上函数调用和返回都是栈啊

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月24日

#41 楼 @luikore lua 虽然是栈，就是基本不做 push/pop 的

Python 和 Ruby 通常情况都是相当于是每个函数独立分别固定大小的内存作为栈的，和寄存器机并没有显著区别。

求推荐颜色或计算公式 at 2013年07月24日

同求配色公式 ...

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月24日

#39 楼 @luikore

{function, fib, 1, 2}.
  {label,1}.
    {line,[{location,"fib.erl",5}]}.
    {func_info,{atom,fib},{atom,fib},1}.
  {label,2}.
    {test,is_integer,{f,4},[{x,0}]}.
    {select_val,{x,0},{f,4},{list,[{integer,1},{f,3},{integer,0},{f,3}]}}.
  {label,3}.
    {move,{integer,1},{x,0}}.
    return.
  {label,4}.
    {allocate_zero,1,1}.
    {line,[{location,"fib.erl",10}]}.
    {gc_bif,'-',{f,0},1,[{x,0},{integer,1}],{x,1}}.
    {move,{x,0},{y,0}}.
    {move,{x,1},{x,0}}.
    {line,[{location,"fib.erl",10}]}.
    {call,1,{f,2}}.
    {line,[{location,"fib.erl",10}]}.
    {gc_bif,'-',{f,0},1,[{y,0},{integer,2}],{x,1}}.
    {move,{x,0},{y,0}}.
    {move,{x,1},{x,0}}.
    {line,[{location,"fib.erl",10}]}.
    {call,1,{f,2}}.
    {line,[{location,"fib.erl",10}]}.
    {gc_bif,'+',{f,0},1,[{y,0},{x,0}],{x,0}}.
    {deallocate,1}.
    return.

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月24日

#34 楼 @luikore 现在是为了比较速度啊，明显运行速度越慢越容易比出来啊，运行速度太快，误差都比运行时间长就坑爹了。

JavaScript 开了 JIT 才比 Erlang 快没多少，这怎么解释... Pypy 开了 JIT 还不如 Erlang

Ruby 的字节码和 Python 几乎完全一样，但是速度确比 Python 快了一倍，都赶上 lua 了，这怎么解释。

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#27 楼 @luikore

代码分别抄自http://rosettacode.org/wiki/Fibonacci_sequence

AWK SWIProlog 和 Python 差不多

Perl 更慢... Tcl 和 Perl 差不多

bc 比 Perl 还慢

目前 Octave 垫底

lua 比 Ruby 快那么点

boo 和 Erlang 差不多

Mozilla 的 JS 参数选对了比 Erlang 快，当然了是开了 JIT，参数js -b -m fib.js比 Erlang 快，参数js -b -j fib.js只能和 Ruby 比比

目前试过的里面纯解释还是 Erlang 最快

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#30 楼 @luikore 根据定义，所有函数最后都会自动加上这个...

我数的是实际会用到的指令。

~~刚才我妄图把那两个指令删了，好像把 Python 解释器搞挂了...~~

可以先用我的 orz 生成一下 bytecode http://xiazheteng.github.io/orz/

from orz.lua.asm import Assembly, Label

from orz.asm import Opcode, StringTable
from orz.symbol import Global, Local, Name, Attribute, calculate_slots

import StringIO
import marshal


def compile_fib(parent, stringtable):
    filename = Name(__file__)
    func_name = Name("fib")

    n = Local("n")
    fib = Global("fib")

    nnames = calculate_slots([n, fib])

    asm = Assembly(
        func_name, *nnames,
        argcount = 1,
        parent = parent)

    asm.set_lineno(1)

    asm.emit(Opcode.LOAD_FAST, n.slot)
    asm.load_const(2)
    asm.emit(Opcode.COMPARE_OP, 0)

    l = Label()

    asm.emit(Opcode.POP_JUMP_IF_FALSE, l)

    asm.load_const(1)
    asm.emit(Opcode.RETURN_VALUE)

    asm.emit(Opcode.LABEL, l)

    asm.emit(Opcode.LOAD_GLOBAL, fib.slot)
    asm.emit(Opcode.LOAD_FAST, n.slot)
    asm.load_const(2)
    asm.emit(Opcode.BINARY_SUBTRACT)
    asm.emit(Opcode.CALL_FUNCTION, 1)

    asm.emit(Opcode.LOAD_GLOBAL, fib.slot)
    asm.emit(Opcode.LOAD_FAST, n.slot)
    asm.load_const(1)
    asm.emit(Opcode.BINARY_SUBTRACT)
    asm.emit(Opcode.CALL_FUNCTION, 1)

    asm.emit(Opcode.BINARY_ADD)
    asm.emit(Opcode.RETURN_VALUE)

    # asm.load_const(None)
    # asm.emit(Opcode.RETURN_VALUE)

    for names in nnames:
        for name in names:
            name.s = stringtable.add(name.name, interned=True)

    func_name.s = stringtable.add(func_name.name, interned=True)

    return asm


def compile_mod():
    stringtable = StringTable()

    filename = Name(__file__)
    fname = Name(__name__)

    fib = Global("fib")

    nnames = calculate_slots([fib])

    asm = Assembly(fname, *nnames)
    asm.set_lineno(1)

    asm.load_const(compile_fib(asm, stringtable))
    asm.emit(Opcode.MAKE_FUNCTION, 0)
    asm.emit(Opcode.STORE_GLOBAL, fib.slot)
    asm.load_const(None)
    asm.emit(Opcode.RETURN_VALUE)

    for names in nnames:
        for name in names:
            name.s = stringtable.add(name.name, interned=True)

    fname.s = stringtable.add(fname.name, interned=True)

    stringtable.close()

    buf = StringIO.StringIO()
    asm.serialize(buf, __file__)
    return marshal.loads(buf.getvalue())


mod = compile_mod()
d = {}
exec mod in d
fib = d['fib']

if __name__=='__main__':
    from timeit import Timer
    t = Timer("print(fib(35))","from __main__ import fib")
    print(t.timeit(1))

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#27 楼 @luikore 不是无值，是 POP_JUMP 顺便 POP 掉了...

erlang 也是纯解释执行啊

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#24 楼 @luikore

Erlang，快得离谱啊，竟然连 1 秒都不要...

-module(fib).

-export([test/0, fib/1]).

fib(0) ->
    1;
fib(1) ->
    1;
fib(N) ->
    fib(N-1)+fib(N-2).

test() ->
    {T, V} = timer:tc(fib, fib, [35]),
    io:format("~w:~w~n", [T,V]).

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#23 楼 @luikore

我贴的那个是 Python2

3 开了 2 没开，2 还比 3 快不少 ... 不科学啊

http://bugs.python.org/issue4753

肯定是 Ruby 用了黑魔法...

Python

def fib(n):
    if n < 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

2           0 LOAD_FAST                0 (n)
            3 LOAD_CONST               1 (2)
            6 COMPARE_OP               0 (<)
            9 POP_JUMP_IF_FALSE       16

3          12 LOAD_CONST               2 (1)
           15 RETURN_VALUE        

5     >>   16 LOAD_GLOBAL              0 (fib)
           19 LOAD_FAST                0 (n)
           22 LOAD_CONST               2 (1)
           25 BINARY_SUBTRACT     
           26 CALL_FUNCTION            1
           29 LOAD_GLOBAL              0 (fib)
           32 LOAD_FAST                0 (n)
           35 LOAD_CONST               1 (2)
           38 BINARY_SUBTRACT     
           39 CALL_FUNCTION            1
           42 BINARY_ADD          
           43 RETURN_VALUE        
           44 LOAD_CONST               0 (None)
           47 RETURN_VALUE

def fib n
  if n < 2
    1
  else
    fib(n - 1) + fib(n - 2)
  end
end

local table (size: 2, argc: 1 [opts: 0, rest: -1, post: 0, block: -1] s1)
[ 2] n<Arg>     
0000 getlocal         n                                               (   1)
0002 putobject        2
0004 opt_lt           <ic:6>
0006 branchunless     12
0008 putobject        1                                               (   2)
0010 leave                                                            (   1)
0011 pop              
0012 putself                                                          (   4)
0013 getlocal         n
0015 putobject        1
0017 opt_minus        <ic:7>
0019 send             :fib, 1, nil, 8, <ic:2>
0025 putself          
0026 getlocal         n
0028 putobject        2
0030 opt_minus        <ic:8>
0032 send             :fib, 1, nil, 8, <ic:4>
0038 opt_plus         <ic:9>
0040 leave

function fib(n)
  if (n<2) then
    return 1
  end

  return fib(n-1)+fib(n-2)
end

function <fib.lua:1,7> (13 instructions, 52 bytes at 0x1120710)
1 param, 4 slots, 0 upvalues, 1 local, 3 constants, 0 functions
    1   [2] LT          0 0 -1  ; - 2
    2   [2] JMP         2   ; to 5
    3   [3] LOADK       1 -2    ; 1
    4   [3] RETURN      1 2
    5   [6] GETGLOBAL   1 -3    ; fib
    6   [6] SUB         2 0 -2  ; - 1
    7   [6] CALL        1 2 2
    8   [6] GETGLOBAL   2 -3    ; fib
    9   [6] SUB         3 0 -1  ; - 2
    10  [6] CALL        2 2 2
    11  [6] ADD         1 1 2
    12  [6] RETURN      1 2
    13  [7] RETURN      0 1

还 Ruby 多一条指令...

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题? at 2013年07月23日

#17 楼 @luikore

Python

==8232== I   refs:      24,435,810,159
==8232== I1  misses:           424,549
==8232== LLi misses:             7,356
==8232== I1  miss rate:           0.00%
==8232== LLi miss rate:           0.00%
==8232== 
==8232== D   refs:      11,447,475,486  (8,210,939,243 rd   + 3,236,536,243 wr)
==8232== D1  misses:           505,807  (      410,181 rd   +        95,626 wr)
==8232== LLd misses:            57,991  (       23,760 rd   +        34,231 wr)
==8232== D1  miss rate:            0.0% (          0.0%     +           0.0%  )
==8232== LLd miss rate:            0.0% (          0.0%     +           0.0%  )
==8232== 
==8232== LL refs:              930,356  (      834,730 rd   +        95,626 wr)
==8232== LL misses:             65,347  (       31,116 rd   +        34,231 wr)
==8232== LL miss rate:             0.0% (          0.0%     +           0.0%  )

Ruby

==8464== I   refs:      14,783,720,041
==8464== I1  misses:           137,316
==8464== LLi misses:             9,038
==8464== I1  miss rate:           0.00%
==8464== LLi miss rate:           0.00%
==8464== 
==8464== D   refs:       6,208,884,291  (3,666,216,719 rd   + 2,542,667,572 wr)
==8464== D1  misses:           205,003  (      150,900 rd   +        54,103 wr)
==8464== LLd misses:            57,501  (       17,151 rd   +        40,350 wr)
==8464== D1  miss rate:            0.0% (          0.0%     +           0.0%  )
==8464== LLd miss rate:            0.0% (          0.0%     +           0.0%  )
==8464== 
==8464== LL refs:              342,319  (      288,216 rd   +        54,103 wr)
==8464== LL misses:             66,539  (       26,189 rd   +        40,350 wr)
==8464== LL miss rate:             0.0% (          0.0%     +           0.0%  )