;; run sim for four hours
;;
(define *end-time* (* 60 50))
;; create the cpus
;;
(let loop ((count 200))
(add-cpu (conc "cpu_" count) 1 1)
(if (>= count 0)(loop (- count 1))))
;; (draw-cpus)
(define *pool1* (new-pool "generic" 20 20 12 80 2 4))
(let loop ((count 10))
(pool:add-cpu *pool1* (conc count) 1 1)
(if (> count 0)
(loop (- count 1))))
(pool:draw *ezx* *pool1*)
;; ;; init the queues
;; ;;
;; (hash-table-set! *queues* "normal" '())
;; (hash-table-set! *queues* "quick" '())
;; (draw-queues)
;;
;; ;; user k adds 200 jobs at time zero
;; ;;
;; (event *start-time*
;; (lambda ()
;; (let loop ((count 300)) ;; add 500 jobs
;; (add-job "normal" "k" 600 1 1)
;; (if (>= count 0)(loop (- count 1))))))
;;
;; ;; one minute in user m runs ten jobs
;; ;;
;; (event (+ 600 *start-time*)
;; (lambda ()
;; (let loop ((count 300)) ;; add 100 jobs
;; (add-job "normal" "m" 600 1 1)
;; (if (> count 0)(loop (- count 1))))))
;;
;; ;; every minute user j runs ten jobs
;; ;;
;; (define *user-j-jobs* 300)
;; (event (+ 600 *start-time*)
;; (lambda ()
;; (let f ()
;; (schedule 60)
;; (if (> *user-j-jobs* 0)
;; (begin
;; (let loop ((count 5)) ;; add 100 jobs
;; (add-job "quick" "j" 600 1 1)
;; (if (> count 0)(loop (- count 1))))
;; (set! *user-j-jobs* (- *user-j-jobs* 5))))
;; (if (and (not *done*)
;; (> *user-j-jobs* 0))
;; (f))))) ;; Megatest user running 200 jobs
;;
;; ;; every minute user j runs ten jobs
;; ;;
;; (define *user-j-jobs* 300)
;; (event (+ 630 *start-time*)
;; (lambda ()
;; (let f ()
;; (schedule 60)
;; (if (> *user-j-jobs* 0)
;; (begin
;; (let loop ((count 5)) ;; add 100 jobs
;; (add-job "quick" "n" 600 1 1)
;; (if (> count 0)(loop (- count 1))))
;; (set! *user-j-jobs* (- *user-j-jobs* 5))))
;; (if (and (not *done*)
;; (> *user-j-jobs* 0))
;; (f))))) ;; Megatest user running 200 jobs
;;
;; ;; ;;
;; ;; (event *start-time*
;; ;; (lambda ()
;; ;; (let f ((count 200))
;; ;; (schedule 10)
;; ;; (add-job "normal" "t" 60 1 1)
;; ;; (if (and (not *done*)
;; ;; (>= count 0))
;; ;; (f (- count 1))))))
;;
;; ;; every 3 seconds check for available machines and launch a job
;; ;;
;; (event *start-time*
;; (lambda ()
;; (let f ()
;; (schedule 3)
;; (let ((queue-names (random-sort (hash-table-keys *queues*))))
;; (let loop ((cpu (get-cpu))
;; (count (+ (length queue-names) 4))
;; (qname (car queue-names))
;; (remq (cdr queue-names)))
;; (if (and cpu
;; (> count 0))
;; (begin
;; (if (peek-job qname) ;; any jobs to do in normal queue
;; (let ((job (take-job qname)))
;; (run-job cpu job)))
;; (loop (get-cpu)
;; (- count 1)
;; (if (null? remq)
;; (car queue-names)
;; (car remq))
;; (if (null? remq)
;; (cdr queue-names)
;; (cdr remq)))))))
;; (if (not *done*)(f)))))
;;
;; ;; screen updates
;; ;;
(event *start-time* (lambda ()
(let f ()
(schedule 60) ;; update the screen every 60 seconds of sim time
;; (draw-cpus) ;; (print "Now: " *now* " queue: " (hash-table->alist *queues*))
(pool:draw *ezx* *pool1*)
(wait-for-next-draw-time)
(if (not *done*) (f)))))
;;
;;
;; ;; end the simulation
;; ;;
(event *end-time*
(lambda ()
(set! *event-list* '())
(set! *done* #t)))
;;
(start)
;; ;; (exit 0)
;;