如果协议函数返回的常量未缓存，则返回结果的速度更快

Question

我正在写一个实体组件系统。它的一部分是定义如何使用Systems的协议。协议的一部分是返回系统运行所需组件的函数。它可以浓缩为以下内容:

(defprotocol System
  (required-components [sys]
    "Returns a map of keys and initial values of components that the System requires to operate.")

因为这个函数返回的值实际上是一个常量，我认为缓存它可能是一个好主意，因为它可能需要每秒+60次。为了判断它是否会产生影响，我编写了以下测试:

(defrecord Input-System1 []
  System
  (required-components [sys] {:position [0 0] :angle 0}))
(def req-comps
  {:position [0 0] :angle 0})
(defrecord Input-System2 []
  System
  (required-components [sys] req-comps))

然后在REPL中运行以下时间测试:

(let [sys (->Input-System1)]
  (time-multiple 1000000000
    (required-components sys)))
(let [sys (->Input-System2)]
  (time-multiple 1000000000
    (required-components sys)))

(以下time-multiple代码)。

奇怪的是，Input-System1总是比Input-System2完成得更快:2789.973066ms vs 3800.345803ms在最后一次运行。

我觉得这很奇怪，尽管从理论上讲，版本1不断地重新创建组件映射，而版本2只引用一个预定义的值。

我试着通过删除协议来重新创建这个:

(defn test-fn1 []
  req-comps)
(defn test-fn2 []
  {:position [0 0] :angle 0})
(time-multiple 1000000000
  (test-fn1))
(time-multiple 1000000000
  (test-fn2))

但这一次，结果几乎相同:3789.478675ms vs 3767.577814ms。

这让我相信它与协议有关，但我不知道是什么。这是怎么回事?我知道，考虑到测试的数量，1000ms是相当微不足道的，所以我在这里并没有尝试进行微优化。我只是好奇。

(defmacro time-pure
  "Evaluates expr and returns the time it took.
  Modified the native time macro to return the time taken."
  [expr]
  `(let [start# (current-nano-timestamp)
         ret# ~expr]
     (/ (double (- (current-nano-timestamp) start#)) 1000000.0)))

(defmacro time-multiple
  "Times the expression multiple times, returning the total time taken, in ms"
  [times expr]
  `(time-pure
     (dotimes [n# ~times]
      ~expr)))

Answer 1

无论哪种情况，您的map都是一个常量，在类加载期间创建(它是静态已知的，因此在方法调用期间不会创建新对象)。另一方面，缓存的用例需要额外的间接操作——访问一个变量。

来演示:

(def req-comps
   {:position [0 0] :angle 0})
(defn asystem-1 []
   {:position [0 0] :angle 0})
(defn asystem-2 []
   req-comps)

(不管我们是否处理协议——函数都是一样编译的，只是这样更容易在编译后的代码中找到它们)

public final class core$asystem_1 extends AFunction {
    public static final AFn const__4 = (AFn)RT.map(new Object[]{RT.keyword((String)null, "position"), Tuple.create(Long.valueOf(0L), Long.valueOf(0L)), RT.keyword((String)null, "angle"), Long.valueOf(0L)});
    public core$asystem_1() {
    }
    public static Object invokeStatic() {
        return const__4;
    }
    public Object invoke() {
        return invokeStatic();
    }
}

看-它只是返回预先计算的常数。

public final class core$asystem_2 extends AFunction {
    public static final Var const__0 = (Var)RT.var("so.core", "req-comps");
    public core$asystem_2() {
    }
    public static Object invokeStatic() {
        return const__0.getRawRoot();
    }
    public Object invoke() {
        return invokeStatic();
    }
}

对getRawRoot()的额外调用