Patch title: Release 90 bulk changes
Abstract:
File: /linux/kernel/statistics.pli
Key:
    Removed line
    Added line
   
module "/pliant/language/compiler.pli"
module "/pliant/language/context.pli"
module "/pliant/language/stream.pli"
module "/pliant/language/schedule/daemon.pli"


module "/pliant/language/compiler.pli"
module "/pliant/language/context.pli"
module "/pliant/language/stream.pli"
module "/pliant/language/schedule/daemon.pli"


type NetStatRecord
type KernelStatRecord
  field DateTime timestamp
  field DateTime timestamp
  field (Dictionary Str Intn) in out
  field (Dictionary Str Intn) net_in net_out
  field (Dictionary Str Intn) disk_read disk_write
  field Intn interrupts
  field Intn cpu


gvar Sem sem
gvar DateTime last_timestamp
  field Intn cpu


gvar Sem sem
gvar DateTime last_timestamp
gvar (Dictionary Str uInt) in_mark out_mark
gvar (Dictionary Str Intn) in_total out_total ; gvar Intn cp
gvar List:NetStatRecord stat
gvar (Dictionary Str uInt) net_in_mark net_out_mark
gvar (Dictionary Str Intn) net_in_total net_out_total
gvar (Dictionary Str uInt) disk_read_mark disk_write_mark
gvar (Dictionary Str Intn) disk_read_total disk_write_total
gvar uInt interrupts_mark
gvar Intn interrupts_total := 0
gvar Intn cpu_total := 0
gvar List:KernelStatRecord stat






function pick_disk_marks read_mark write_mark interrupts
  arg_w (Dictionary Str uInt) read_mark write_mark ; arg_w uInt interrupts
  read_mark := var (Dictionary Str uInt) empty_dictionary ; write_mark := var (Dictionary Str uInt) empty_dictionary
  (var Stream proc) open "file:/proc/stat" in+safe
  while not proc:atend
    var Str l := proc readline
    if (l parse word:"disk_io" ":" any:(var Str disks))
      while (disks parse "(" any:(var Str disk) ")" ":" "(" (var uInt nb_rw) "," (var uInt nb_read) "," (var uInt sec_read) "," (var uInt nb_write) "," (var uInt sec_write) ")" any:(var Str remain))
        read_mark insert disk sec_read ; write_mark insert disk sec_write
        disks := remain
    eif (l parse word:"intr" interrupts any)
      void

function pick_cpu_load load
  arg_w Float load
  (var Stream proc) open "file:/proc/loadavg" in+safe
  if (proc:readline parse (var Float l1) (var Float l2) (var
    load := l1
  else
    load := 0

function add_stat_record
function pick_cpu_load load
  arg_w Float load
  (var Stream proc) open "file:/proc/loadavg" in+safe
  if (proc:readline parse (var Float l1) (var Float l2) (var
    load := l1
  else
    load := 0

function add_stat_record
  pick_net_marks (var (Dictionary Str uInt) in) (var (Dictio
  each m in
    var Str d := in key m
    in_total d 0 += m .-. (in_mark d 0)
    in_mark d := m
  each m out
    var Str d := out key m
    out_total d 0 += m .-. (out_mark d 0)
    out_mark d := m
  pick_net_marks (var (Dictionary Str uInt) net_in) (var (Dictionary Str uInt) net_out)
  each m net_in
    var Str d := net_in key m
    net_in_total d 0 += m .-. (net_in_mark d 0)
    net_in_mark d := m
  each m net_out
    var Str d := net_out key m
    net_out_total d 0 += m .-. (net_out_mark d 0)
    net_out_mark d := m
  pick_disk_marks (var (Dictionary Str uInt) disk_read) (var (Dictionary Str uInt) disk_write) (var uInt interrupts)
  each m disk_read
    var Str d := disk_read key m
    disk_read_total d 0 += m .-. (disk_read_mark d 0)
    disk_read_mark d := m
  each m disk_write
    var Str d := disk_write key m
    disk_write_total d 0 += m .-. (disk_write_mark d 0)
    disk_write_mark d := m
  interrupts_total += interrupts .-. interrupts_mark
  interrupts_mark := interrupts
  pick_cpu_load (var Float load)
  var DateTime now := datetime
  var Int sec := cast now:seconds-last_timestamp:seconds Int
  cpu_total += cast sec*load*1000 Int
  last_timestamp := now
  pick_cpu_load (var Float load)
  var DateTime now := datetime
  var Int sec := cast now:seconds-last_timestamp:seconds Int
  cpu_total += cast sec*load*1000 Int
  last_timestamp := now
  var Link:NetStatRecord r :> new NetStatRecord
  var Link:KernelStatRecord r :> new KernelStatRecord
  r timestamp := now
  r timestamp := now
  r in := in_total ; r out := out_total ; r cpu := cpu_total
  r net_in := net_in_total ; r net_out := net_out_total
  r disk_read := disk_read_total ; r disk_write := disk_write_total
  r interrupts := interrupts_total
  r cpu := cpu_total
  sem request
  stat += r
  sem release


function filter_stat_records
  var DateTime now := datetime  
  sem request
  var Float mini := resolution
  sem request
  stat += r
  sem release


function filter_stat_records
  var DateTime now := datetime  
  sem request
  var Float mini := resolution
  var Pointer:NetStatRecord r :> stat last
  while { var Pointer:NetStatRecord r2 :> stat previous r ; 
  var Pointer:KernelStatRecord r :> stat last
  while { var Pointer:KernelStatRecord r2 :> stat previous r ; exists:r2 }
    if now:seconds-r2:timestamp:seconds<mini
      stat remove r
    else
      mini := 1.25*mini
    r :> r2
  sem release
 

function gather_statistics
  daemon "gather Linux kernel statistics"
    if now:seconds-r2:timestamp:seconds<mini
      stat remove r
    else
      mini := 1.25*mini
    r :> r2
  sem release
 

function gather_statistics
  daemon "gather Linux kernel statistics"
    pick_net_marks in_mark out_mark
    in_total := var (Dictionary Str Intn) empty_dict ; out_t
    pick_net_marks net_in_mark net_out_mark
    net_in_total := var (Dictionary Str Intn) empty_dict ; net_out_total := var (Dictionary Str Intn) empty_dict ; cpu_total := 0
    last_timestamp := datetime
    last_timestamp := datetime
    stat := var List:NetStatRecord empty_list
    stat := var List:KernelStatRecord empty_list
    add_stat_record
    var Int lap := 0
    while not daemon_emergency
      daemon_sleep resolution
      add_stat_record
      lap += 1
      if lap%6=0
        filter_stat_records
gather_statistics


function net_devices -> devices
  arg List:Str devices
  devices := var List:Str empty_list
    add_stat_record
    var Int lap := 0
    while not daemon_emergency
      daemon_sleep resolution
      add_stat_record
      lap += 1
      if lap%6=0
        filter_stat_records
gather_statistics


function net_devices -> devices
  arg List:Str devices
  devices := var List:Str empty_list
  each c in_total
    devices += in_total key c
  each c net_in_total
    devices += net_in_total key c

function net_statistics device seconds in_bps out_bps
  arg Str device ; arg Float seconds ; arg_w Float in_bps ou
  sem rd_request

function net_statistics device seconds in_bps out_bps
  arg Str device ; arg Float seconds ; arg_w Float in_bps ou
  sem rd_request
  var Pointer:NetStatRecord last :> stat last
  var Pointer:NetStatRecord r :> last
  var Pointer:KernelStatRecord last :> stat last
  var Pointer:KernelStatRecord r :> last
  while last:timestamp:seconds-r:timestamp:seconds<seconds a
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:second
  if sec<1
    sec := 1
  if device<>""
  while last:timestamp:seconds-r:timestamp:seconds<seconds a
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:second
  if sec<1
    sec := 1
  if device<>""
    in_bps := (cast (last:in first device 0)-(r:in first dev
    out_bps := (cast (last:out first device 0)-(r:out first 
    in_bps := (cast (last:net_in first device 0)-(r:net_in first device 0) Float)*8/sec
    out_bps := (cast (last:net_out first device 0)-(r:net_out first device 0) Float)*8/sec
  else
    in_bps := 0
  else
    in_bps := 0
    each c last:in
      var Str d := last:in key c
      in_bps += (cast (last:in first d 0)-(r:in first d 0) F
    each c last:net_in
      var Str d := last:net_in key c
      if d<>"lo"
        in_bps += (cast (last:net_in first d 0)-(r:net_in first d 0) Float)*8/sec
    out_bps := 0
    out_bps := 0
    each c last:out
      var Str d := last:out key c
      out_bps += (cast (last:out first d 0)-(r:out first d 0
    each c last:net_out
      var Str d := last:net_out key c
      if d<>"lo"
        out_bps += (cast (last:net_out first d 0)-(r:net_out first d 0) Float)*8/sec
  sem rd_release


  sem rd_release


function disk_devices -> devices
  arg List:Str devices
  devices := var List:Str empty_list
  each c disk_read_total
    devices += disk_read_total key c

function disk_statistics device seconds read_bps write_bps
  arg Str device ; arg Float seconds ; arg_w Float read_bps write_bps
  sem rd_request
  var Pointer:KernelStatRecord last :> stat last
  var Pointer:KernelStatRecord r :> last
  while last:timestamp:seconds-r:timestamp:seconds<seconds and exists:(stat previous r)
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:seconds
  if sec<1
    sec := 1
  if device<>""
    read_bps := (cast (last:disk_read first device 0)-(r:disk_read first device 0) Float)*512*8/sec
    write_bps := (cast (last:disk_write first device 0)-(r:disk_write first device 0) Float)*512*8/sec
  else
    read_bps := 0
    each c last:disk_read
      var Str d := last:disk_read key c
      read_bps += (cast (last:disk_read first d 0)-(r:disk_read first d 0) Float)*512*8/sec
    write_bps := 0
    each c last:disk_write
      var Str d := last:disk_write key c
      write_bps += (cast (last:disk_write first d 0)-(r:disk_write first d 0) Float)*512*8/sec
  sem rd_release


function interrupts_statistics seconds -> ips
  arg Float seconds ; arg Float ips
  sem rd_request
  var Pointer:KernelStatRecord last :> stat last
  var Pointer:KernelStatRecord r :> last
  while last:timestamp:seconds-r:timestamp:seconds<seconds and exists:(stat previous r)
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:seconds
  if sec<1
    sec := 1
  ips := (cast last:interrupts-r:interrupts Float)/sec
  sem rd_release

function cpu_statistics seconds -> load
  arg Float seconds ; arg Float load
  sem rd_request
function cpu_statistics seconds -> load
  arg Float seconds ; arg Float load
  sem rd_request
  var Pointer:NetStatRecord last :> stat last
  var Pointer:NetStatRecord r :> last
  var Pointer:KernelStatRecord last :> stat last
  var Pointer:KernelStatRecord r :> last
  while last:timestamp:seconds-r:timestamp:seconds<seconds a
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:second
  if sec<1
    sec := 1
  load := (cast last:cpu-r:cpu Float)/1000/sec
  sem rd_release

  while last:timestamp:seconds-r:timestamp:seconds<seconds a
    r :> stat previous r
  var Float sec := last:timestamp:seconds-r:timestamp:second
  if sec<1
    sec := 1
  load := (cast last:cpu-r:cpu Float)/1000/sec
  sem rd_release

export net_devices net_statistics cpu_statistics
export net_devices net_statistics
export disk_devices disk_statistics
export interrupts_statistics cpu_statistics