Nim 概念 Concept 对性能的影响

继上一篇文章《C# 泛型编译特性对性能的影响》后，我又研究了 Nim 语言相关的设计，由于 Nim 语言与 C# 语言有些差异，比如Nim 没有接口，也没有直接的 class 关键字，所以某些实现是变通的办法。

概念 Concept

在Nim中没有 Interface 的概念，虽然有多次提案，但似乎语言设计者一直拒绝这一设计，他们提供了 Concept 这一方案。他与C#的interface的相似点包括：

• concept和interface都用于定义抽象类型和行为规范，允许在没有提供具体实现的情况下定义方法签名。
• 两者都支持多态，允许不同的类型实现相同的接口或概念，并以相同的方式被操作或使用。

但也有不同之处，比如：

• 在Nim的concept中，方法声明不需要关键字（如fn），而是直接指定方法的签名。在C#中，interface中的方法声明需要使用method或property等关键字。
• concept在Nim中比interface更加灵活。concept可以用于限制多个类型的行为，但不一定需要显式声明实现。它允许在函数中使用未显式声明为实现concept的类型。interface在C#中更加严格，要求类型明确地声明并实现接口中的所有成员。
• 在C#中，interface可以在字段、方法参数、方法返回值等多个地方使用，允许动态地访问实现。在Nim中，concept主要用于参数约束，只允许在函数或过程中使用，无法在字段或返回值中声明。

下面是这个案例中声明 Concept 的例子：

type
    IValueGetter = concept s
        s.getValue(int32) is int64

有了 concept，我们就可以在泛型中约束 泛型参数的行为，例如下面的泛型类型 MyTestClass[T] ，其类型声明中没有约束 T，但在相关的方法中，允许约束。

type
    MyTestClass[T] = object
        valueGetter: T

proc run[T: IValueGetter](this: MyTestClass[T]): int64 =
    var r = 0i64
    let n = high(int32) - rand(100).int32
    for i in 0 ..< n:
      r += this.valueGetter.getValue(i)
    return r

Nim 中 Struct 和 Class

在Nim语言中， struct 是使用 object 关键字，同样的，如果在object 的前面加上 ref 关键字，就变成了 struct 引用，自然就相当于 class 了,下面是示例代码：

type
    StructValueGetter = object
    StructValueGetter2 = object
        someField: int

    ValueGetter = ref object of RootObj
    ClassValueGetter1 = ref object of ValueGetter
    ClassValueGetter2 = ref object of ValueGetter

在这个例子中，我们看见如何声明 Struct，以及声明字段， 同时也使用 ref object 声明了 class ，他使用 of 关键字表示继承关系。

你也许注意到，RootObj ，他是nim语言提供的默认基类，你可以理解为c#和java 的object 基类，但nim语言具有很强的灵活性，可以不继承任何基类，或使用其他的基类。

Nim中定义方法或动态方法

一般情况下，Nim建议使用 proc 和 func 作为方法前的关键字，因为这样的话方法就是静态编译的，具有最佳的性能，func 其实是 proc 的特例，即表示无副作用的 proc，比如你仅仅是读取对象的数据，不会破坏结构，这就是无副作用。

# 实现 IValueGetter 的 concept
func getValue(this: StructValueGetter, index: int32): int64 =
    result = index.int64 + 3i64

func getValue(this: StructValueGetter2, index: int32): int64 =
    result = index.int64 + 5i64

func getValue(this: ClassValueGetter1, index: int32): int64 =
    result = index.int64 + 5i64

func getValue(this: ClassValueGetter2, index: int32): int64 =
    result = index.int64 + 7i64

为实现诸如 c# 的虚方法功能（即动态调用），nim 设计了 method 关键字。

method getValueCore(this: ValueGetter, index: int32): int64 {.base.} =
    quit "to overrdie"

method getValueCore(this: ClassValueGetter1, index: int32): int64 =
    return getValue(this,index)

method getValueCore(this: ClassValueGetter2, index: int32): int64 =
    return getValue(this,index)

# 为 ValueGetter 实现契约，相当于使用契约调用的是虚方法。
proc getValue(this: ValueGetter, index: int32): int64 =
    return getValueCore(this, index)

测试

下面我们将使用 stuct 和 class 两种形式，确定 concept 和 泛型结合，对性能的影响。同时我们也观察动态方法调用，即虚方法的调用对性能的影响。

import std/[times],std/random
type
    IValueGetter = concept s
        s.getValue(int32) is int64

    MyTestClass[T] = object
        valueGetter: T

proc run[T: IValueGetter](this: MyTestClass[T]): int64 =
    var r = 0i64
    let n = high(int32) - rand(100).int32
    for i in 0 ..< n:
      r += this.valueGetter.getValue(i)
    return r

type
    StructValueGetter = object
    StructValueGetter2 = object
        someField: int

    ValueGetter = ref object of RootObj
    ClassValueGetter1 = ref object of ValueGetter
    ClassValueGetter2 = ref object of ValueGetter

# 实现 IValueGetter 的 concept
func getValue(this: StructValueGetter, index: int32): int64 =
    result = index.int64 + 3i64

func getValue(this: StructValueGetter2, index: int32): int64 =
    result = index.int64 + 5i64

func getValue(this: ClassValueGetter1, index: int32): int64 =
    result = index.int64 + 5i64

func getValue(this: ClassValueGetter2, index: int32): int64 =
    result = index.int64 + 7i64

# 为接口 ValueGetter 实现契约，相当于使用契约调用的是委托。
method getValueCore(this: ValueGetter, index: int32): int64 {.base.} =
    quit "to overrdie"

method getValueCore(this: ClassValueGetter1, index: int32): int64 =
    return getValue(this,index)

method getValueCore(this: ClassValueGetter2, index: int32): int64 =
    return getValue(this,index)

proc getValue(this: ValueGetter, index: int32): int64 =
    return getValueCore(this, index)

proc measureTime(caption: string, procToMeasure: proc(): int64) =
  var startTime = cpuTime()
  let r = procToMeasure()
  var endTime = cpuTime()
  echo caption, " time = ", endTime - startTime, " result = ", r

# 运行测试
proc main() =
    randomize()
    let t1 = MyTestClass[StructValueGetter](valueGetter : StructValueGetter())
    measureTime("StructValueGetter ", proc ():int64 = t1.run() )
    let t2 = MyTestClass[ClassValueGetter1](valueGetter : new(ClassValueGetter1))
    measureTime("ClassValueGetter1 ", proc ():int64 = t2.run() )
    let t3 = MyTestClass[ClassValueGetter2](valueGetter : new(ClassValueGetter2))
    measureTime("ClassValueGetter2 ", proc ():int64 = t3.run())
    let t4 = MyTestClass[ValueGetter](valueGetter : new(ClassValueGetter1))
    measureTime("IValueGetter-1    ", proc ():int64 = t4.run())

    let t5 = MyTestClass[ClassValueGetter1](valueGetter : new(ClassValueGetter1))
    measureTime("ClassValueGetter1 ", proc ():int64 = t5.run())
    let t6 = MyTestClass[StructValueGetter2](valueGetter : StructValueGetter2())
    measureTime("StructValueGetter2", proc ():int64 = t6.run())


when isMainModule:
  main()

编译的命令行如下：

nim c -d:release -x --checks:off  -r ".\demo1.nim"

请自己编译时将 demo1.nim 替换成自己的文件名，同时你也可能注意到 我关闭了检查，我发现如果不关闭的话，性能会慢很多。在我的笔记本电脑的参考结果如下：

StructValueGetter  time = 0.429 result = 2305842997402533900
ClassValueGetter1  time = 0.421 result = 2305842825603845693
ClassValueGetter2  time = 0.421 result = 2305842971632730244
IValueGetter-1     time = 4.74 result = 2305842913650672596
ClassValueGetter1  time = 0.4210000000000003 result = 2305842870701000726
StructValueGetter2 time = 0.4190000000000005 result = 2305842920093123411

我们注意到：

• 在nim语言实现中 , struct 和 class 在泛型和 concept 的环境下，性能几乎没有影响；
• 与c#不同，nim仍然为每种 class 编译不同的程序，所以性能不会变化；
• 尽量避免使用虚方法，性能的损失很大；