Нужно оптимизировать мой код Clojure, который занимает слишком много времени

transform выполняет несколько чрезвычайно дорогостоящих операций каждый раз в цикле. count и nth в ленивой последовательности занимают O(n) времени. Вместо того, чтобы использовать любой из них, обработайте последовательность лениво с помощью first и next.

Я не люблю код-гольф, но кажется, что это довольно просто уменьшит. Мы хотим подсчитать частоту перехода, поэтому давайте просто сделаем это:

  (with-open [reader (clojure.java.io/reader "My_Big_Log")]
    (frequencies
     (map #(re-find #"[a-z]+\.[a-z]+\.[a-z]+")
          (line-seq reader))))

Подсчет рефереров путем создания списка всех 2 миллионов из них, а затем его сортировка и разбиение на разделы означает, что вы носите с собой большое количество ненужных данных. Это делает это в пространственной сложности O (рефереры), а не O (строки), что в зависимости от ваших журналов может быть огромным сокращением.

Мне также непонятно, почему вы используете core.async. Это мало что добавит к этому простому подсчету и очень затруднит понимание того, что происходит в коде.

Наконец - просто профиль. Он покажет вам много интересного о вашем коде, о котором вы, возможно, не знали.

sort на 2 млн записей работает медленно. Плюс count и nth также дороги в ленивой последовательности. Вы можете избежать их (вместе со всеми промежуточными последовательностями) с преобразователем. На моем MBP 2M записей заняло ~ 5 секунд.

(defn transform [input-f output-f]
  (let [read-ch  (chan 1 (comp (map (partial re-find #"[a-z]+\.[a-z]+\.[a-z]+"))
                               ;; remove other lines
                               (remove nil?)
                               ;; transducer bag is like a set but with counter. e.g. {"a.b.c" 1  "c.d.e" 3}
                               (bag)
                               ;; make each map entry as a sequence element (["a.b.c" 1] ["c.d.e" 3])
                               cat
                               ;; generate output lines
                               (map-indexed (fn [i [x cnt]]
                                              [(str "Referrer " i ": " x)
                                               (str "Number of entries associated with this referrer: " cnt)]))
                               ;; flatten the output lines  (["l1" "l2"] ["l3" "l4"]) => ("l1" "l2" "l3" "l4")
                               cat))
        write-ch (chan)]

    ;; wire up read-ch to write-ch
    (pipe read-ch write-ch true)

    ;; spin up a thread to read all lines into read-ch
    (thread
      (with-open [reader (io/reader input-f)]
        (<!! (onto-chan read-ch (line-seq reader) true))))

    ;; write the counted lines to output
    (with-open [wtr (io/writer output-f)]
      (loop []
        (when-let [temp (<!! write-ch)]
          (.write wtr (str temp "\n"))
          (recur))))))

(time
 (transform "input.txt" "output.txt"))
;; => "Elapsed time: 5286.222668 msecs"

А вот «одноразовый» счетный мешок, который я использовал:

(defn bag []
  (fn [rf]
    (let [state (volatile! nil)]
      (fn
        ([] (rf))
        ([result] (if @state
                    (try
                      (rf result @state)
                      (finally
                        (vreset! state nil)))
                    (rf result)))
        ([result input]
         (vswap! state update input (fnil inc 0))
         result)))))

Вот пример вывода:

Referrer 0: h.i.j
Number of entries associated with this referrer: 399065
Referrer 1: k.l.m
Number of entries associated with this referrer: 400809
Referrer 2: a.b.c
Number of entries associated with this referrer: 400186
Referrer 3: c.d.e
Number of entries associated with this referrer: 399667
Referrer 4: m.n.o
Number of entries associated with this referrer: 400273