I have a function that will run repeatedly, so I use the at-at library to 
call it:

https://github.com/overtone/at-at

I don't think this is the problem. 

Sad to say, the Error is catching a StackOverflow, which I'm having trouble 
finding. I don't see a place where I call a function recursively, so I 
don't see where any of this becomes stackoverflow. 

I'm using Dire to catch errors, but for now I'm just logging them. I don't 
see anything fancy or clever that would give me a stackoverflow, and yet 
this anonymous function called by at-at is definitely giving rise to 
StackOverflow.

(defn- calculate--scores []
  (let [my-pool (at/mk-pool)]
    (at/every 180000
              (fn []
                (append-to-file "/var/log/example/-scores.log" "Will 
attempt to write scores")
                (future 
                  (try 
                    (let [
                          map-of-all-sums   (api/get-accuracy-and-precision)
                          set-of-all-scores (dire/supervise 
#'api/path-entries map-of-all-sums)
                          path-and--scores (dire/supervise 
#'api/loop-over-scores set-of-all-scores)
                          ]
                      (append-to-file "/var/log/example/-scores.log" 
"\n\n\n\n\n")
                      (append-to-file "/var/log/example/-scores.log" " 
path-and--scores: ")
                      (append-to-file "/var/log/example/-scores.log"  (str 
"(count set-of-all-scores): " (count set-of-all-scores)))
                      (append-to-file "/var/log/example/-scores.log" 
path-and--scores))
                    (catch Exception e
                      (do
                        (append-to-file "/var/log/example/-scores.log" (str 
" EXCEPTION:: " e))
                        (append-to-file "/var/log/example/-scores.log" 
(stack/parse-exception e))
                        (errors/error e)))
                    (catch Error o
                      (println (str " a problem in the anonymous function 
in calculate--scores: " o)))
                    )))
              my-pool)))


The problem appears to be here, which will loop several thousand times and 
then die. But I don't see why. (This function used to just be a loop, and I 
added the (let) so I could see if I could read the end -- but I could not 
reach the end).



(defn loop-over-scores
  [set-of-scores]
  "2017-03-08 -- called from start.clj"
  (try
    (let [return-value  (loop [
                               how-many-loops 0
                               scores set-of-scores
                               vector-of-maps-of-vector-key-and-score []
                               ]

                          (println  (str  " in loop-over-scores again " 
how-many-loops))
                          (if (next scores)
                            (recur
                             (inc how-many-loops)
                             (remove #{(first scores)} scores)
                             (conj vector-of-maps-of-vector-key-and-score 
(find-related-positive-negative-true-false-records scores (first scores))))
                            vector-of-maps-of-vector-key-and-score))
          ]

      (println " return-value in loop-over-scores " return-value " in 
loop-over-scores")
      return-value)
    (catch Exception e (println " exception in loop-over-scores: " e))))


So this line prints out a result several thousand times:

      (println " return-value in loop-over-scores " return-value " in 
loop-over-scores")


And then I get stackoverflow.

But nothing seems suspicious here:


(defn find-related-positive-negative-true-false-records [set-of-scores 
vector-with-path-score]
  (println " in find-related-positive-negative-true-false-records the 
vector-with-path-score "  vector-with-path-score)
  
  (let [
        [vector-with-path score] vector-with-path-score
        ;; 2017-03-08 -- seq-as-path should be something like [30 8 34 
20.94 2]
        seq-as-path (rest (rest vector-with-path))

        ;;_ (append-to-file "/var/log/example/-scores.log" "seq-as-path")
        ;;         _ (append-to-file "/var/log/example/-scores.log" 
seq-as-path)
    
        vector-as-path (apply conj [] seq-as-path)

         _ (append-to-file "/var/log/example/-scores.log" "vector-as-path")
         _ (append-to-file "/var/log/example/-scores.log" vector-as-path)
        ]
    (dire/supervise #'map-of-vector-path-and-true-false-scores 
vector-as-path)))


Nor here:


(defn map-of-vector-path-and-true-false-scores
  [vector-as-path]
  (println " at the start of map-of-vector-path-and-true-false-scores")
  (try 
    (if-not (empty? vector-as-path)
      (let [
            ;; 2017-03-30 -- this fails:
            ;; user> (apply conj [:positive :false] (30 6 40))
            ;; ClassCastException java.lang.Long cannot be cast to 
clojure.lang.IFn  user/eval1719 (NO_SOURCE_FILE:1)
            ;;
            ;; but this works: 
            ;; user> (apply conj [:positive :false] '(30 6 40))
            ;;[:positive :false 30 6 40]
            ;;

            true-positive-path  (apply conj [:positive :true] 
vector-as-path)
            false-positive-path  (apply conj [:positive :false] 
vector-as-path)
            false-negative-path  (apply conj [:negative :false] 
vector-as-path)

            true-positive (get-in @accuracy-and-precision 
true-positive-path 0)
            _ (append-to-file "/var/log/example/paths-with-score.log" (str 
true-positive-path " score: " true-positive))

            false-positive (get-in @accuracy-and-precision 
false-positive-path 0) 
            _ (append-to-file "/var/log/example/paths-with-score.log"  
(str  false-positive-path " score: " false-positive))
            
            false-negative (get-in @accuracy-and-precision 
false-negative-path 0)
            _ (append-to-file "/var/log/example/paths-with-score.log"  
(str  false-negative-path " score:  "  false-negative))
            
            ]      
        { vector-as-path (dire/supervise #'calculate--score true-positive 
false-positive false-negative) }))
    (catch Exception e (println " problem in 
map-of-vector-path-and-true-false-scores  " e))
    (catch Error o (println " problem without exception in 
map-of-vector-path-and-true-false-scores " o))
    ))

Nor here:


(defn calculate--score [true-positive false-positive false-negative]  
  (let [
        twice-true-positive (* true-positive 2)
        denominator (+ twice-true-positive false-negative false-positive)
        ]
    (if (> denominator 0)
      (/ twice-true-positive denominator)
      0)))


There is nothing here where a function calls itself over and over, so what 
would lead to StackOverflow?

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to