#! /usr/local/X11R5/bin/wish -f
#
# This program is an interface to the PVM test suite. Written by Emmanual Jeannot
# and Philip Mucci at the University of Tennessee in Knoxville. Help is available
# through cs.utk.edu. Some of the fileselector code was originally written by
# Mario Jorge Silva(msilva@cs.Berkeley.EDU). 
# 
# Philip Mucci (mucci@cs.utk.edu)
# Emmanuel Jeannot (jeannot@cs.utk.edu) (ejeannot@ens.ens-lyon.fr)
#
#
# Default font settings
#
option add *Listbox*font \
    "-*-helvetica-medium-r-normal-*-12-*-*-*-p-*-iso8859-1" startupFile
option add *Entry*font \
    "-*-helvetica-medium-r-normal-*-12-*-*-*-p-*-iso8859-1" startupFile
option add *Label*font \
    "-*-helvetica-medium-r-normal-*-12-*-*-*-p-*-iso8859-1" startupFile
option add *Scale*font \
    "-*-helvetica-medium-r-normal-*-10-*-*-*-p-*-iso8859-1" startupFile
option add *Text*font \
    "6x13" startupFile
#
# Default global variable settings
#
set pvm_test_gui_pid [pid]
set pvm_test_pid 0
set pvm_root ""
set pvm_arch ""
set num_procs 5
set siz_mesgs 100
set num_mesgs 10
set bw_start 100
#set bw_end [expr $bw_start*32]
#set bw_inc [expr $bw_end/64]
set bw_end 1000
set bw_inc 100
set atime_bool 0
set all_comb_bool 0
set ttime_bool 0
set pvm_hostfile ""
set hostfile_buffer ""
set onelabeltest ""
set pvm_test_status ""
set helpmsg "Help messages appear here."

#
# Procedures
#

proc KillTester { } {
  global pvm_test_pid pvm_test_gui_pid

  catch {exec kill -30 $pvm_test_pid}
}

proc IsProcessRunning { pid } {
  update
  set processes [string trim [exec ps]]
  if {[regexp "$pid " $processes] == 0} {
    return 0
  } else {
    return 1 }
}

proc RunTester { } {
  global pvm_test_gui_pid pvm_test_pid errorCode pvm_root pvm_arch pvm_test_status 

  exec rm -f /tmp/ptg.status.$pvm_test_gui_pid
  if { $errorCode != "NONE" } {
    error "Could not remove /tmp/ptg.status.$pvm_test_gui_pid."
    return }

# tkwait variable pvm_root
#  exec $pvm_root/lib/pvm &
#  after 4000 
  set pvm_test_pid [exec ~/pvm3/bin/$pvm_arch/pvm_test /tmp/ptg.infile.$pvm_test_gui_pid > /tmp/ptg.status.$pvm_test_gui_pid 2> /tmp/ptg.status.$pvm_test_gui_pid &]

  destroy .generic
  PutGeneric .generic
  grab set .generic
  pack .generic -side bottom -anchor sw -expand true -fill both
  button .generic.abort -text ABORT -bd 2 -fg red -command { KillTester }
  label .generic.status -textvariable pvm_test_status -relief sunken -bd 1 -bg white -fg black
  pack .generic.status -side top -fill both -pady 2 -padx 2
  pack .generic.abort -side bottom -fill both -pady 2 -padx 2

  set i 0
  while { 1 } {
    set pvm_test_status [exec tail -1 /tmp/ptg.status.$pvm_test_gui_pid]
    update
    if {[expr $i % 5] == 0} {
      if {[expr ($i/5) % 2] == 0} {
	.generic.status configure -bg black -fg white
      } else {
	.generic.status configure -bg white -fg black } }
    if {[expr $i % 10] == 0} {
      if { [IsProcessRunning $pvm_test_pid] == 0} {
        destroy .generic.abort
	break } }
    set i [expr $i + 1]
  }

  set pvm_test_status [exec tail -1 /tmp/ptg.status.$pvm_test_gui_pid]
  update
  exec rm -f /tmp/ptg.status.$pvm_test_gui_pid /tmp/ptg.infile.$pvm_test_gui_pid

  if {[file exists /tmp/ptg.rpt.$pvm_test_gui_pid] && [file size /tmp/ptg.rpt.$pvm_test_gui_pid]} {
    button .generic.view -text "View/Save results" -bd 2 -command { PutResults } 
  } else {
    button .generic.view -text "View/Save results" -bd 2 -state disabled }
  button .generic.done -text "Done" -bd 2 -command { DoneResultsForGood }
  pack .generic.status -side top -fill both -pady 2 -padx 2
  pack .generic.done .generic.view -side bottom -fill both -padx 2 -pady 2
}

proc MakeSel { } {
  global hostfile_buffer
  frame .top.r3panel 
  pack .top.r3panel -side top -expand true -fill both -padx 2 -pady 2 -anchor nw

  label .top.r3panel.actions -text "Actions"
  button .top.r3panel.rsel -text "Run selection" -bd 3 -command { RunSel }
  pack .top.r3panel.actions .top.r3panel.rsel  -side top -fill x -padx 3
  bind .top.r3panel.rsel <Enter> { 
    set helpmsg "Guess what this does?" 
    tk_butEnter %W }

  label .top.r3panel.select -text "Test groups"
  pack .top.r3panel.select -side top -fill both -padx 3
  checkbutton .top.r3panel.alltests -text "All available tests" -anchor w -variable alltests
  bind .top.r3panel.alltests <Enter> { 
    set helpmsg "Perform all 91 tests. This might take quite a while!" 
    tk_butEnter %W }
  checkbutton .top.r3panel.allmsg -text "All messaging tests" -anchor w -variable allmsg 
  bind .top.r3panel.allmsg <Enter> { 
    set helpmsg "Perform the funneling, head-to-head and triangle tests, both with and without data." 
    tk_butEnter %W }
  checkbutton .top.r3panel.allrtin  -text "All routine tests" -anchor w -variable allrtin
  bind .top.r3panel.allrtin <Enter> { 
    set helpmsg "Perform tests on the host, group, buffer, task, broadcast and other functions." 
    tk_butEnter %W }
  checkbutton .top.r3panel.fdat -text "All funneling tests with data" -anchor w -variable fdat
  bind .top.r3panel.fdat <Enter> { 
    set helpmsg "Perform the test where one host gathers messages from many." 
    tk_butEnter %W }
  checkbutton .top.r3panel.fndat -text "All funneling tests with no data" -anchor w -variable fndat
  bind .top.r3panel.fndat <Enter> { 
    set helpmsg "Perform the test where one host gathers messages from many, but no actual data is sent." 
    tk_butEnter %W }
  checkbutton .top.r3panel.hdat -text "All head-head with data" -anchor w -variable hdat
  bind .top.r3panel.hdat <Enter> { 
    set helpmsg "Perform the bidirectional communication test." 
    tk_butEnter %W }
  checkbutton .top.r3panel.hndat -text "All head-head with no data" -anchor w -variable hndat
  bind .top.r3panel.hndat <Enter> { 
   set helpmsg "Perform the bidirectional communication test, but no actual data is sent." 
    tk_butEnter %W }
  checkbutton .top.r3panel.tdat -text "All triangle with data" -anchor w -variable tdat
  bind .top.r3panel.tdat <Enter> { 
    set helpmsg "Perform the test where one host sends to the next forming a loop." 
    tk_butEnter %W }
  checkbutton .top.r3panel.tndat -text "All triangle with no data" -anchor w -variable tndat
  bind .top.r3panel.tndat <Enter> { 
    set helpmsg "Perform the test where one host sends to the next forming a loop, but no actual data is sent." 
    tk_butEnter %W }
  checkbutton .top.r3panel.bw -text "Bandwidth and latency tests" -anchor w -variable bw
  bind .top.r3panel.bw <Enter> { 
    set helpmsg "Plot a graph of latency vs. message size between the first *two* hosts." 
    tk_butEnter %W }

  button .top.r3panel.onetest -text "Select one test..." -bd 3 -command { OneTest }
  bind .top.r3panel.onetest <Enter> { 
    set helpmsg "Pick a singular test from the complete list." 
    tk_butEnter %W }

  pack .top.r3panel.alltests .top.r3panel.allmsg .top.r3panel.allrtin .top.r3panel.fdat .top.r3panel.fndat \
       .top.r3panel.hdat .top.r3panel.hndat .top.r3panel.tdat .top.r3panel.tndat .top.r3panel.bw \
       .top.r3panel.onetest  -side top -fill both -expand true -padx 3 

  bind .top.r3panel.alltests <ButtonRelease-1> {
       tk_butUp %W
       if { $alltests != 0 } {
	 .top.r3panel.allmsg deselect
	 .top.r3panel.allrtin deselect
         .top.r3panel.fdat deselect
         .top.r3panel.fndat deselect
         .top.r3panel.hdat deselect
         .top.r3panel.hndat deselect
         .top.r3panel.tdat deselect
         .top.r3panel.tndat deselect
         .top.r3panel.bw deselect
	 .top.r3panel.allmsg configure -state disabled
	 .top.r3panel.allrtin configure -state disabled
         .top.r3panel.fdat configure -state disabled
         .top.r3panel.fndat configure -state disabled
         .top.r3panel.hdat configure -state disabled
         .top.r3panel.hndat configure -state disabled
         .top.r3panel.tdat configure -state disabled
         .top.r3panel.tndat configure -state disabled
         .top.r3panel.bw configure -state disabled 
       } else {
     	 .top.r3panel.allmsg configure -state normal
	 .top.r3panel.allrtin configure -state normal
         .top.r3panel.fdat configure -state normal
         .top.r3panel.fndat configure -state normal
         .top.r3panel.hdat configure -state normal
         .top.r3panel.hndat configure -state normal
         .top.r3panel.tdat configure -state normal
         .top.r3panel.tndat configure -state normal
         .top.r3panel.bw configure -state normal } }
   bind .top.r3panel.allmsg <ButtonRelease-1> {
	tk_butUp %W
	if { $allmsg != 0 } {
         .top.r3panel.fdat deselect
         .top.r3panel.fndat deselect
         .top.r3panel.hdat deselect
         .top.r3panel.hndat deselect
         .top.r3panel.tdat deselect
         .top.r3panel.tndat deselect
         .top.r3panel.fdat configure -state disabled
         .top.r3panel.fndat configure -state disabled
         .top.r3panel.hdat configure -state disabled
         .top.r3panel.hndat configure -state disabled
         .top.r3panel.tdat configure -state disabled
         .top.r3panel.tndat configure -state disabled
       } else {
         .top.r3panel.fdat configure -state normal
         .top.r3panel.fndat configure -state normal
         .top.r3panel.hdat configure -state normal
         .top.r3panel.hndat configure -state normal
         .top.r3panel.tdat configure -state normal
         .top.r3panel.tndat configure -state normal } }
   bind .top.r3panel.allrtin <ButtonRelease-1> {
        tk_butUp %W
	if { $allrtin != 0 } {
	  .top.r3panel.bw deselect 
	  .top.r3panel.bw configure -state disabled 
        } else {
	  .top.r3panel.bw configure -state normal } }
}

proc RunSel { } {
global pvm_hostfile pvm_test_gui_pid

  StoreHostFileInBuffer
  if {[HasATestSelected]} {
    if {[CheckHostFileBuffer]} {
      MakeInFile /tmp/ptg.infile.$pvm_test_gui_pid /tmp/ptg.rpt.$pvm_test_gui_pid
      RunTester
    } else {
      error "You must have a valid PVM hostfile to run the tests." }
  } 
}

proc OneTest { } {
  global hostfile_buffer onelabeltest

  set onelabeltest ""
  .top.r3panel.alltests deselect
  .top.r3panel.allmsg deselect
  .top.r3panel.allrtin deselect
  .top.r3panel.fdat deselect
  .top.r3panel.fndat deselect
  .top.r3panel.hdat deselect
  .top.r3panel.hndat deselect
  .top.r3panel.tdat deselect
  .top.r3panel.tndat deselect
  .top.r3panel.bw deselect
  .top.r3panel.onetest configure -state disabled
  .top.r3panel.alltests configure -state disabled
  .top.r3panel.allmsg configure -state disabled
  .top.r3panel.allrtin configure -state disabled
  .top.r3panel.fdat configure -state disabled
  .top.r3panel.fndat configure -state disabled
  .top.r3panel.hdat configure -state disabled
  .top.r3panel.hndat configure -state disabled
  .top.r3panel.tdat configure -state disabled
  .top.r3panel.tndat configure -state disabled
  .top.r3panel.bw configure -state disabled
  .top.menu_bar.file configure -state disabled
  .top.menu_bar.output configure -state disabled

  StoreHostFileInBuffer
  destroy .generic
  PutGeneric .generic
  bind .generic <Enter> { 
    set helpmsg "Pick a singular test from the complete list." }

  frame .generic.file -bd 3 -relief ridge 
  frame .generic.bframe -bd 3 -relief ridge 
  frame .generic.file.sframe -relief ridge
  scrollbar .generic.file.sframe.r3panelscroll -command ".generic.file.sframe.r3paneltests yview"
  listbox .generic.file.sframe.r3paneltests -font 7x14 -relief sunken -yscrollcommand ".generic.file.sframe.r3panelscroll set"
  button .generic.bframe.cancel -text cancel -relief raised -padx 10 -command {
    .top.r3panel.onetest configure -state normal
    .top.r3panel.alltests configure -state normal
    .top.r3panel.allmsg configure -state normal
    .top.r3panel.allrtin configure -state normal
    .top.r3panel.fdat configure -state normal
    .top.r3panel.fndat configure -state normal
    .top.r3panel.hdat configure -state normal
    .top.r3panel.hndat configure -state normal
    .top.r3panel.tdat configure -state normal
    .top.r3panel.tndat configure -state normal
    .top.r3panel.bw configure -state normal
    .top.menu_bar.file configure -state normal
    .top.menu_bar.output configure -state normal
    PutText
    .generic.frame.tframe.text insert end $hostfile_buffer
    set onelabeltest "" }
    
  .generic.file.sframe.r3paneltests insert end "test001: Pvm_mstat() corect"
  .generic.file.sframe.r3paneltests insert end "test002: pvm_mstat() incorect"
  .generic.file.sframe.r3paneltests insert end "test003: pvm_addhosts() correct"                                        
  .generic.file.sframe.r3paneltests insert end "test004: pvm_delhosts() incorrect"
  .generic.file.sframe.r3paneltests insert end "test005: pvm_delhosts() correct"
  .generic.file.sframe.r3paneltests insert end "test006: pvm_delhosts() incorrect"
  .generic.file.sframe.r3paneltests insert end "test007: Race pvm_addhosts()-pvm_config()"
  .generic.file.sframe.r3paneltests insert end "test008: Race pvm_delhosts()-pvm_config()"
  .generic.file.sframe.r3paneltests insert end "test009: pvm_hostsync()"
  .generic.file.sframe.r3paneltests insert end "test010: pvm_pstat() correct"
  .generic.file.sframe.r3paneltests insert end "test011: pvm_pstat() incorrect"
  .generic.file.sframe.r3paneltests insert end "test012: pvm_spawn() sequential"
  .generic.file.sframe.r3paneltests insert end "test013: pvm_spawn() simultaneous"
  .generic.file.sframe.r3paneltests insert end "test014: pvm_kill() correct"
  .generic.file.sframe.r3paneltests insert end "test015: pvm_kill() incorrect"
  .generic.file.sframe.r3paneltests insert end "test016: pvm_tidtohost()"
  .generic.file.sframe.r3paneltests insert end "test017: pvm_parent()"
  .generic.file.sframe.r3paneltests insert end "test018: pvm_sendsig()"
  .generic.file.sframe.r3paneltests insert end "test019: pvm_task()"
  .generic.file.sframe.r3paneltests insert end "test020: pvm_exit()"
  .generic.file.sframe.r3paneltests insert end "test021: Are several group server started ?"
  .generic.file.sframe.r3paneltests insert end "test022: pvm_joingroup() incorrect"
  .generic.file.sframe.r3paneltests insert end "test023: pvm_lvgroup() incorrect"
  .generic.file.sframe.r3paneltests insert end "test024: pvm_joingroup(),pvm_lvgroup(),pvm_gsize()"
  .generic.file.sframe.r3paneltests insert end "test025: Group completion"
  .generic.file.sframe.r3paneltests insert end "test026: pvm_getinst(),pvm_gettid()"
  .generic.file.sframe.r3paneltests insert end "test027: pvm_initsend(),pvm_getsbuf(),pvm_freebuf()"
  .generic.file.sframe.r3paneltests insert end "test028: pvm_pkxxx(),pvm_upkxxx()"
  .generic.file.sframe.r3paneltests insert end "test029: pvm_getrbuf()"
  .generic.file.sframe.r3paneltests insert end "test030: pvm_bufinfo()"
  .generic.file.sframe.r3paneltests insert end "test031: pvm_mytid()"
  .generic.file.sframe.r3paneltests insert end "test032: pvm_mkbuf()"
  .generic.file.sframe.r3paneltests insert end "test033: pvm_(p)send()-pvm_(p)recv() coherency"
  .generic.file.sframe.r3paneltests insert end "test034: pvm_setsbuf()"
  .generic.file.sframe.r3paneltests insert end "test035: pvm_setrbuf()"
  .generic.file.sframe.r3paneltests insert end "test036: pvm_setxbuf() incorrect"
  .generic.file.sframe.r3paneltests insert end "test037: pvm_bcast()"
  .generic.file.sframe.r3paneltests insert end "test038: pvm_barrier()"
  .generic.file.sframe.r3paneltests insert end "test039: pvm_reduce()"
  .generic.file.sframe.r3paneltests insert end "test040: pvm_gather()"
  .generic.file.sframe.r3paneltests insert end "test041: pvm_scatter()"
  .generic.file.sframe.r3paneltests insert end "test042: pvm_mcast()"
  .generic.file.sframe.r3paneltests insert end "test043: pvm_trecv()"
  .generic.file.sframe.r3paneltests insert end "test044: pvm_nrecv()"
  .generic.file.sframe.r3paneltests insert end "test045: Latency-Bandwidth pvm_send()-pvm_recv()"
  .generic.file.sframe.r3paneltests insert end "test046: Latency-Bandwidth pvm_psend()-pvm_precv()"
  .generic.file.sframe.r3paneltests insert end "test047: pvm_notify()"
  .generic.file.sframe.r3paneltests insert end "test048: head-head, PvmDataDefault, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test049: head-head, PvmDataRaw, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test050: head-head, PvmDataInPlace, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test051: head-head, PvmDataDefault, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test052: head-head, PvmDataRaw, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test053: head-head, PvmDataInPlace, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test054: head-head, -, daemon routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test055: head-head, -, direct routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test056: head-head, PvmDataDefault, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test057: head-head, PvmDataRaw, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test058: head-head, PvmDataInPlace, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test059: head-head, PvmDataDefault, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test060: head-head, PvmDataRaw, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test061: head-head, PvmDataInPLace, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test062: head-head, -, daemon routing, psend, data"
  .generic.file.sframe.r3paneltests insert end "test063: head-head, -, direct routing, psend, data"
  .generic.file.sframe.r3paneltests insert end "test064: triangle, PvmDataDefault, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test065: triangle, PvmDataRaw, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test066: triangle, PvmDataInPlace, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test067: triangle, PvmDataDefault, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test068: triangle, PvmDataRaw, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test069: triangle, PvmDataInPlace, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test070: triangle, -, daemon routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test071: triangle, -, direct routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test072: triangle, PvmDataDefault, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test073: triangle, PvmDataRaw, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test074: triangle, PvmDataInPlace, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test075: triangle, PvmDataDefault, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test076: triangle, PvmDataRaw, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test077: triangle, PvmDataInPLace, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test078: triangle, -, daemon routing, psend, data"
  .generic.file.sframe.r3paneltests insert end "test079: triangle, -, direct routing, psend, data"
  .generic.file.sframe.r3paneltests insert end "test080: funneling, PvmDataDefault, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test081: funneling, PvmDataRaw, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test082: funneling, PvmDataInPlace, daemon routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test083: funneling, PvmDataDefault, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test084: funneling, PvmDataRaw, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test085: funneling, PvmDataInPlace, direct routing, send, empty"
  .generic.file.sframe.r3paneltests insert end "test086: funneling, PvmDataDefault, daemon routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test087: funneling, PvmDataRaw, daemon routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test088: funneling, PvmDataInPlace, daemon routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test089: funneling, PvmDataDefault, direct routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test090: funneling, PvmDataRaw, direct routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test091: funneling, PvmDataInPlace, direct routing, mcast, empty"
  .generic.file.sframe.r3paneltests insert end "test092: funneling, -, daemon routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test093: funneling, -, direct routing, psend, empty"
  .generic.file.sframe.r3paneltests insert end "test094: funneling, PvmDataDefault, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test095: funneling, PvmDataRaw, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test096: funneling, PvmDataInPlace, daemon routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test097: funneling, PvmDataDefault, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test098: funneling, PvmDataRaw, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test099: funneling, PvmDataInPlace, direct routing, send, data"
  .generic.file.sframe.r3paneltests insert end "test100: funneling, PvmDataDefault, daemon routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test101: funneling, PvmDataRaw, daemon routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test102: funneling, PvmDataInPlace, daemon routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test103: funneling, PvmDataDefault, direct routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test104: funneling, PvmDataRaw, direct routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test105: funneling, PvmDataInPlace, direct routing, mcast, data"
  .generic.file.sframe.r3paneltests insert end "test106: funneling, -, daemon routing, psend, data"
  .generic.file.sframe.r3paneltests insert end "test107: funneling, -, direct routing, psend, data"

  pack .generic.file -padx 5 -pady 5 -side left -anchor nw -expand true -fill both 
  pack .generic.bframe -padx 5 -pady 5 -side right -fill x 
  pack .generic.file.sframe -side top -expand true -fill both
  pack .generic.file.sframe.r3panelscroll -side right -fill y
  pack .generic.file.sframe.r3paneltests -side left -fill both -expand true
  pack .generic.bframe.cancel -fill x -ipady 10

  tk_listboxSingleSelect .generic.file.sframe.r3paneltests
  bind .generic.file.sframe.r3paneltests  <Button-1> {
    %W select from [%W nearest %y]
    set onelabeltest [string range [%W get [%W nearest %y]] 0 6] }
}

proc fileselect.ok.cmd {w cmd} {
    global fileselect

    set selected [$fileselect(entry) get]
    set trimmed [string trim $selected]

    if {[string length $trimmed] == 0} {
    	return }

    if {[file isdirectory $trimmed] != 0} {
    	# clean the text entry and prepare the list
	$fileselect(entry) delete 0 end
	$fileselect(list) delete 0 end
	cd $trimmed
	set dir [pwd]
	$fileselect(dirlabel) configure -text $dir
	foreach i [exec /bin/ls -a $dir] {
	  if {[file isdirectory $i]} {
	    $fileselect(list) insert end $i/
	  } else {  
	    $fileselect(list) insert end $i }
	}
	return }

    set path [pwd]
    $cmd $trimmed $path
}

proc fileselect.cancel.cmd {w {cmd ""}} {
    if {$cmd != ""} {
      $cmd 
    } else {
      destroy $w
      PutGeneric .generic }
}

proc file_window {w cmd cancel} {
    destroy $w
    PutGeneric $w
    real_file_window "Filename:" $w $cmd $cancel }

proc real_file_window {heading w cmd cancel} {
    label $w.dirlabel -anchor sw -relief ridge -bd 3 -text [pwd] 
    pack $w.dirlabel -side bottom -anchor sw -fill x -padx 5 -pady 5 

    frame $w.file -bd 3 -relief ridge 
    pack $w.file -padx 5 -pady 5 -side left -anchor nw -expand true -fill both 

    frame $w.bframe -bd 3 -relief ridge 
    pack $w.bframe -padx 5 -pady 5 -side right -fill x 

    frame $w.file.eframe -relief ridge
    pack $w.file.eframe -side top -fill both -anchor nw 

    frame $w.file.sframe -relief ridge
    pack $w.file.sframe -side top -expand true -fill both

    label $w.file.eframe.label1 -text "$heading"
    entry $w.file.eframe.entry -relief sunken
    pack $w.file.eframe.label1 $w.file.eframe.entry -side top -fill x

    scrollbar $w.file.sframe.yscroll -relief sunken -command "$w.file.sframe.list yview"
    pack $w.file.sframe.yscroll -side right -fill y

    listbox $w.file.sframe.list -relief sunken \
	-yscroll "$w.file.sframe.yscroll set" 
    pack $w.file.sframe.list -side left -expand true -fill both

    button $w.bframe.ok -text OK -bd 5 -relief raised -padx 10 \
        -command "fileselect.ok.cmd $w $cmd"
    button $w.bframe.cancel -text cancel -relief raised -padx 10 \
        -command "fileselect.cancel.cmd $w $cancel"
    pack $w.bframe.ok $w.bframe.cancel -fill x -ipady 10

    # path independent names for the widgets
    global fileselect

    set fileselect(entry) $w.file.eframe.entry
    set fileselect(list) $w.file.sframe.list
    set fileselect(scroll) $w.file.sframe.scroll
    set fileselect(ok) $w.bframe.ok
    set fileselect(cancel) $w.bframe.cancel
    set fileselect(dirlabel) $w.dirlabel

    # Fill the listbox with a list of the files in the directory (run
    # the "/bin/ls" command to get that information).

    foreach i [exec /bin/ls -a [pwd]] {
      if {[file isdirectory $i]} {
	$w.file.sframe.list insert end $i/
      } else {  
	$w.file.sframe.list insert end $i }
    }

    # Set up bindings for the window
    bind $w <Return> {eval $fileselect(ok) invoke}
    bind $w <Control-c> {eval $fileselect(cancel) invoke}

    # Set up bindings for the entry field.
    bind $fileselect(entry) <Return> {eval $fileselect(ok) invoke}
    bind $fileselect(entry) <Control-c> {eval $fileselect(cancel) invoke}

    tk_listboxSingleSelect $fileselect(list)

    bind $fileselect(list) <Button-1> {
        # puts stderr "button 1 release"
        %W select from [%W nearest %y]
	$fileselect(entry) delete 0 end
	$fileselect(entry) insert 0 [%W get [%W nearest %y]]
    }

    bind $fileselect(list) <Key> {
        %W select from [%W nearest %y]
        $fileselect(entry) delete 0 end
	$fileselect(entry) insert 0 [%W get [%W nearest %y]]
    }

    bind $fileselect(list) <Double-ButtonPress-1> {
        # puts stderr "double button 1"
        %W select from [%W nearest %y]
	$fileselect(entry) delete 0 end
	$fileselect(entry) insert 0 [%W get [%W nearest %y]]
	$fileselect(ok) invoke
    }

    bind $fileselect(list) <Return> {
        %W select from [%W nearest %y]
	$fileselect(entry) delete 0 end
	$fileselect(entry) insert 0 [%W get [%W nearest %y]]
	$fileselect(ok) invoke
    }

    # set kbd focus to entry widget

    focus $fileselect(entry)
}

proc PutGeneric { name } {
  frame $name -relief raised -bd 2 
  pack $name -side bottom -anchor sw -fill both
}

#
# Post the results window.
#

proc PutResults { } {
  global pvm_test_gui_pid
  toplevel .results
  wm maxsize .results 1000 500
  wm minsize .results 250 125

  grab set .results

  frame .results.top 
  pack .results.top -side top -fill both -expand true

  frame .results.top.sframe 
  pack .results.top.sframe -side left -fill both -expand true

  frame .results.top.bframe -relief ridge -bd 3 
  pack .results.top.bframe -side right
  button .results.top.bframe.save -text Save -command { SaveResults }
  button .results.top.bframe.done -text Done -command { DoneResults }
#  button .results.top.bframe.save_graph -text "Save Graph" -command { SaveGraph } -state disabled
#  pack .results.top.bframe.save .results.top.bframe.done .results.top.bframe.save_graph -side top -fill both
  pack .results.top.bframe.save .results.top.bframe.done -side top -fill both

  frame .results.top.sframe.right 
  label .results.top.sframe.right.l2 -text "Summary"
  pack .results.top.sframe.right -side right -expand true -fill both -padx 5
  pack .results.top.sframe.right.l2 -side top

  listbox .results.top.sframe.right.outcome -bd 2 -relief sunken \
    -yscrollcommand ".results.top.sframe.right.yscroll set" \
    -xscrollcommand ".results.top.sframe.right.xscroll set" 
  scrollbar .results.top.sframe.right.yscroll -command ".results.top.sframe.right.outcome yview" 
  scrollbar .results.top.sframe.right.xscroll -orient horizontal -command ".results.top.sframe.right.outcome xview" 
  pack .results.top.sframe.right.yscroll -side right -fill y 
  pack .results.top.sframe.right.xscroll -side bottom -fill x 
  pack .results.top.sframe.right.outcome -side right -expand true -fill both 
  tk_listboxSingleSelect .results.top.sframe.right.outcome 

  frame .results.top.sframe.left 
  label .results.top.sframe.left.l1 -text "Data (Click on a test to view)"
  pack .results.top.sframe.left -side left -expand true -fill both
  pack .results.top.sframe.left.l1 -side top

  text .results.top.sframe.left.info -bd 2 -relief sunken -yscrollcommand ".results.top.sframe.left.yscroll set" -wrap word
  scrollbar .results.top.sframe.left.yscroll -command ".results.top.sframe.left.info yview" 
  pack .results.top.sframe.left.info -side left -fill both
  pack .results.top.sframe.left.yscroll -side left -fill y 

  .results.top.sframe.right.outcome insert end "Report header"
  set fd [open /tmp/ptg.rpt.$pvm_test_gui_pid r]
  while {[gets $fd line] >= 0} {
    if {[string match test#*:* $line] == 1} {
      set name [string trim [string range $line 0 [expr [string first ":" $line]-1]]]
      gets $fd line
      while {[string match test#*:* $line] != 1} {
        gets $fd line}
      set result [string trim [string range $line [expr [string last ":" $line]+2] end]]
      if { $name == "test#45" } {
        set name "send :latency-bandwidth 1" }
       if { $name == "test#46" } {
        set name "psend :latency-bandwidth 2" }
      .results.top.sframe.right.outcome insert end "$name: $result"
    } elseif {[lrange $line 2 3] == "time totals"} {
      .results.top.sframe.right.outcome insert end "[lrange $line 0 0] timings"
    } } 
  close $fd

  bind .results.top.sframe.right.outcome <Button-1> {
    set cmp [string range [.results.top.sframe.right.outcome get [.results.top.sframe.right.outcome nearest %y]] 0 7]
    if { $cmp == "send :la" } { 
      FindAndInsertInformation "test#45:"
    } elseif { $cmp == "psend :l"} {
	FindAndInsertInformation "test#46:"
	} elseif { $cmp == "Report h" } {
      FindAndInsertInformation "--------"
    } else {
      FindAndInsertInformation $cmp } }
}

proc InsertBlockOfInformation { fd } {
  while {[gets $fd line] >= 0} {
    set begline [string range $line 0 3]
    if {$begline=="test"||$begline=="funn"||$begline=="head"||$begline=="tria"} {
      return 
    } else {
      .results.top.sframe.left.info insert end "$line\n" }
  }
}

proc FindAndInsertInformation { first_eight_chars } {
global pvm_test_gui_pid

  set fd [open /tmp/ptg.rpt.$pvm_test_gui_pid r]
  while {[gets $fd line] >= 0} {
    if {[string match $first_eight_chars* $line] == 1} {
      .results.top.sframe.left.info delete 1.0 end
      .results.top.sframe.left.info insert end "$line\n"	
      InsertBlockOfInformation $fd
      close $fd
      return 
    } }
  return 
}

#
# Finished dealing with the results window.
#

proc DoneResults { } {
  destroy .results
  grab set .generic
}

#
# Finished dealing with the results for good.
#

proc DoneResultsForGood { } {
  global pvm_test_gui_pid pvm_test_pid
  exec rm -f /tmp/ptg.rpt.$pvm_test_gui_pid /tmp/ptg.status.$pvm_test_gui_pid /tmp/ptg.hosts.$pvm_test_gui_pid 
  OpenClickedCancel
}

#
# Save the report file generated by pvm_test.
#

proc SaveResults { } {
  .results.top.bframe.save configure -state disabled
  frame .results.bottom 
  pack .results.bottom -side bottom -expand true -fill both
  frame .results.bottom.fframe 
  pack .results.bottom.fframe -side bottom -expand true -fill both
  grab .results.bottom.fframe
  real_file_window "Filename for report:" .results.bottom.fframe SaveResultsOK SaveResultsCancel
}
proc SaveResultsOK { name path } {
  global pvm_test_gui_pid
  if {[string index [string trim $name] 0] == "/"} {
    set outname "$name"
  } else {
    set outname "$path/$name"    
  }
  exec cp /tmp/ptg.rpt.$pvm_test_gui_pid $outname
  destroy .results.bottom
  .results.top.bframe.save configure -state normal
}
proc SaveResultsCancel { } {
  destroy .results.bottom
  .results.top.bframe.save configure -state normal }

#
# Save the postscript file generated by GNUPLOT
#

proc SaveGraph { } {
  .results.top.bframe.save_graph configure -state disabled
  frame .results.bottom2 
  pack .results.bottom2 -side bottom -expand true -fill both
  frame .results.bottom2.fframe 
  pack .results.bottom2.fframe -side bottom -expand true -fill both
  grab .results.bottom2.fframe
  real_file_window "Filename for PS graph:" .results.bottom2.fframe SaveGraphOK SaveGraphCancel
}
proc SaveGraphOK { name path } {
  global pvm_test_gui_pid
  if {[string index [string trim $name] 0] == "/"} {
    set outname "$name"
  } else {
    set outname "$path/$name"    
  }
  exec cp "/tmp/ptg.ps.$pvm_test_gui_pid" $outname
  destroy .results.bottom2
  .results.top.bframe.save_graph configure -state normal
}
proc SaveGraphCancel { } {
  destroy .results.bottom2
  .results.top.bframe.save_graph configure -state normal }

proc PutMenus { } {
  frame .top.menu_bar -relief raised -bd 2
  bind .top.menu_bar <Enter> { 
    set helpmsg "These menus deal with the input to pvm_test and the PVM host file shown below." }

  menubutton .top.menu_bar.file -text "Hosts" -menu .top.menu_bar.file.e
  menu .top.menu_bar.file.e
  .top.menu_bar.file.e add command -label "Open..." -command { Open } 
  .top.menu_bar.file.e add command -label "Save" -command { Save  } 
  .top.menu_bar.file.e add command -label "Save As..." -command { SaveAs } 
  .top.menu_bar.file.e add command -label "Exit" -command { Exit }

  menubutton .top.menu_bar.output -text "Input" -menu .top.menu_bar.output.e
  menu .top.menu_bar.output.e
  .top.menu_bar.output.e add command -label "Save As..." -command { ConfigSaveAs } 

  pack .top.menu_bar -fill x -side top
  pack .top.menu_bar.file .top.menu_bar.output -side left 
}

proc PutHelp { } {
  label .top.help -font "-*-helvetica-medium-r-normal-*-10-*-*-*-p-*-iso8859-1" -textvariable helpmsg -relief ridge -bd 2
  bind .top.help <Enter> { 
    set helpmsg "This panel displays helpful text about the object you're pointing to." }
  pack .top.help -side top -fill both -expand true -padx 5 -pady 2
}

proc PutSliders { } {
  global num_procs siz_mesgs num_mesgs bw_start bw_end bw_inc

  frame .top.r1panel 
  pack .top.r1panel -pady 2 -padx 2 -side right -anchor ne -expand true -fill both

  label .top.r1panel.l1 -text "Messaging tests parameters:" 
  scale .top.r1panel.s1 -label "Number of processes" -from 1 -to 128 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s1 set $num_procs
  scale .top.r1panel.s2 -label "Units per message" -from 1 -to 4096 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s2 set $siz_mesgs
  scale .top.r1panel.s3 -label "Messages per test" -from 1 -to 256 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s3 set $num_mesgs
  pack .top.r1panel.l1 .top.r1panel.s1 .top.r1panel.s2 .top.r1panel.s3 -side top -fill both -expand true

  bind .top.r1panel.s1 <Enter> { 
    set helpmsg "The number of slave processes spawned for the funneling tests." }
  bind .top.r1panel.s2 <Enter> { 
    set helpmsg "The number of units in each message, each unit has one member of each data type." }
  bind .top.r1panel.s3 <Enter> { 
    set helpmsg "The number of times to send the message per process." }
  bind .top.r1panel.s1 <Button-2> {
    set tmp [.top.r1panel.s1 get]
    .top.r1panel.s1 set [expr $tmp-1] }
  bind .top.r1panel.s2 <Button-2> {
    set tmp [.top.r1panel.s2 get]
    .top.r1panel.s2 set [expr $tmp-1] }
  bind .top.r1panel.s3 <Button-2> {
    set tmp [.top.r1panel.s3 get]
    .top.r1panel.s3 set [expr $tmp-1] }
  bind .top.r1panel.s1 <Button-3> {
    set tmp [.top.r1panel.s1 get]
    .top.r1panel.s1 set [expr $tmp+1] }
  bind .top.r1panel.s2 <Button-3> {
    set tmp [.top.r1panel.s2 get]
    .top.r1panel.s2 set [expr $tmp+1] }
  bind .top.r1panel.s3 <Button-3> {
    set tmp [.top.r1panel.s3 get]
    .top.r1panel.s3 set [expr $tmp+1] }

  label .top.r1panel.l2 -text "Bandwidth parameters: (bytes)" 
  scale .top.r1panel.s4 -label "Start" -from 0 -to 10000 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s4 set $bw_start
  scale .top.r1panel.s5 -label "End" -from 1 -to 10000 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s5 set $bw_end
  scale .top.r1panel.s6 -label "Increment" -from 1 -to 1024 -length 150 -orient horizontal -command DoSliders
  .top.r1panel.s6 set $bw_inc
  pack .top.r1panel.s5 .top.r1panel.s6 .top.r1panel.s4 .top.r1panel.l2 -side bottom -fill both -expand true

  bind .top.r1panel.s4 <Enter> { 
    set helpmsg "The starting size of the message to send in the bandwidth test." }
  bind .top.r1panel.s5 <Enter> { 
    set helpmsg "The Maximum size of message to send in the bandwidth test." }
  bind .top.r1panel.s6 <Enter> { 
    set helpmsg "The size increase the message by on each iteration." }
  bind .top.r1panel.s4 <Button-2> {
    set tmp [.top.r1panel.s4 get]
    .top.r1panel.s4 set [expr $tmp-1] }
  bind .top.r1panel.s5 <Button-2> {
    set tmp [.top.r1panel.s5 get]
    .top.r1panel.s5 set [expr $tmp-1] }
  bind .top.r1panel.s6 <Button-2> {
    set tmp [.top.r1panel.s6 get]
    .top.r1panel.s6 set [expr $tmp-1] }
  bind .top.r1panel.s4 <Button-3> {
    set tmp [.top.r1panel.s4 get]
    .top.r1panel.s4 set [expr $tmp+1] }
  bind .top.r1panel.s5 <Button-3> {
    set tmp [.top.r1panel.s5 get]
    .top.r1panel.s5 set [expr $tmp+1] }
  bind .top.r1panel.s6 <Button-3> {
    set tmp [.top.r1panel.s6 get]
    .top.r1panel.s6 set [expr $tmp+1] }
}

proc PutCheckButtons { } {
  global atime_bool ttime_bool all_comb_bool

  label .top.r1panel.l3 -text "General options:" 
  label .top.r1panel.l4 -text "Timing options:"
  checkbutton .top.r1panel.r2 -text "Average Time" -variable atime_bool -anchor w 
  checkbutton .top.r1panel.r3 -text "Total Time" -variable ttime_bool -anchor w
  checkbutton .top.r1panel.r1 -text "All Combinations" -variable all_comb_bool -anchor w 
  pack .top.r1panel -pady 2 -padx 2 -side right -anchor ne -expand true -fill both
  pack .top.r1panel.l3 -fill both -expand true -side top
  pack .top.r1panel.r2 .top.r1panel.r3 -fill both -expand true -side bottom
  pack .top.r1panel.l4 -fill both -expand true -side bottom
  pack .top.r1panel.r1 -fill both -expand true -side bottom

  bind .top.r1panel.r1 <Enter> {
    set helpmsg "Try all architectures combination ?"
    tk_butEnter %W }
  bind .top.r1panel.r2 <Enter> { 
    set helpmsg "Display the amount of time each process took per message"
    tk_butEnter %W }
  bind .top.r1panel.r3 <Enter> { 
    set helpmsg "Display the amount of time each process took to send all the messages"
    tk_butEnter %W }
}

proc PutActionButtons { } {
  MakeSel
}

proc AddHostToList { } {
  global HostList
  set host [.generic.frame.eframe.entry1 get]
  set path [.generic.frame.eframe.entry2 get]
  if {($host != "") && ($path != "")} {
    if {[lsearch $HostList "$host*"] == -1} {
      set entry "$host $path"
      lappend HostList $entry
      set HostList [lsort $HostList]
      .generic.frame.names delete 0 end
      foreach name $HostList {
        .generic.frame.names insert end "$name" }
    }
  } 
}

proc RemHostFromList { } {
  global HostList
  if {[selection own] != ""} {
    foreach host [selection get] {
      set index [lsearch $HostList $host]
      set HostList [lreplace $HostList $index $index]
      .modhost.frame.names delete $index $index } }
}

proc DoSliders value {
  global num_procs siz_mesgs num_mesgs bw_start bw_end bw_inc
  set num_procs [.top.r1panel.s1 get]
  set siz_mesgs [.top.r1panel.s2 get]
  set num_mesgs [.top.r1panel.s3 get]
  set bw_start [.top.r1panel.s4 get]
  set bw_inc [.top.r1panel.s6 get]
  set bw_end [.top.r1panel.s5 get]
}

proc PutText { } {
  destroy .generic
  PutGeneric .generic

  frame .generic.frame -relief ridge 
  pack .generic.frame -side left -anchor nw -expand true -fill both

  frame .generic.frame.tframe -relief ridge
  pack .generic.frame.tframe -side left -fill both -anchor nw

  frame .generic.frame.sframe -relief ridge 
  pack .generic.frame.sframe -side right -fill both 

  scrollbar .generic.frame.sframe.scrollbar -relief sunken -command ".generic.frame.tframe.text yview"
  pack .generic.frame.sframe.scrollbar -side right -fill y

  text .generic.frame.tframe.text -height 10 -yscrollcommand ".generic.frame.sframe.scrollbar set"
  pack .generic.frame.tframe.text -side left -fill both

  bind .generic.frame.tframe.text <Up> {
	.generic.frame.tframe.text mark set "insert" "insert - 1 lines" 
	.generic.frame.tframe.text yview -pickplace "insert" }
  bind .generic.frame.tframe.text <Down> {
	.generic.frame.tframe.text mark set "insert" "insert + 1 lines"
	.generic.frame.tframe.text yview -pickplace "insert" }
  bind .generic.frame.tframe.text <Shift-Up> {
	.generic.frame.tframe.text mark set "insert" "0.0" 
	.generic.frame.tframe.text yview -pickplace "insert" }
  bind .generic.frame.tframe.text <Shift-Down> {
	.generic.frame.tframe.text mark set "insert" "end"
	.generic.frame.tframe.text yview -pickplace "insert" }
  bind .generic.frame.tframe.text <Left> {
	.generic.frame.tframe.text mark set "insert" "insert - 1 chars" }
  bind .generic.frame.tframe.text <Right> {
	.generic.frame.tframe.text mark set "insert" "insert + 1 chars" }
  bind .generic.frame.tframe.text <Enter> {
	set helpmsg "Click here and enter the names and PVM options of the hosts you wish to test, one host per line." }
}

proc HasATestSelected { } {
  global onelabeltest alltests allmsg allrtin fdat fndat hdat hndat tdat tndat bw
  if { $onelabeltest != "" || $alltests || $allmsg || $allrtin || $fdat || $fndat || $hdat || $hndat || $tdat || $tndat || $bw } {
    return 1 
  } else {
    return 0 }
}

proc CheckHostFileBuffer { } {
  global hostfile_buffer

  if {[string trim $hostfile_buffer] == ""} {
    return 0 
  } else {   
    return 1 } 
}

proc StoreHostFileInBuffer { } {
  global hostfile_buffer

  if {[catch {.generic.frame.tframe.text get 1.0 end}] == 0} {
    set hostfile_buffer [.generic.frame.tframe.text get 1.0 end] }
}

proc ConfigSaveAs { } {

  StoreHostFileInBuffer
  if {[HasATestSelected]} {
    if {[CheckHostFileBuffer]} {
      file_window .generic ConfigSaveAsClickedOk SaveAsClickedCancel
    } else {
      error "You must have a valid PVM hostfile to generate the pvm_test input file." }
  } else {
    error "You must select some tests to perform."
  } 
}

proc ConfigSaveAsClickedOk {name path} {
  if {$path != ""} {
    set config_file "$path/$name"
  } else {
    set config_file "$name" 
  }
  MakeInFile $config_file stdout
  SaveAsClickedCancel
}

proc Open { } {
  global hostfile_buffer

  set hostfile_buffer [.generic.frame.tframe.text get 1.0 end]
  file_window .generic OpenClickedOk OpenClickedCancel 
}

proc Save { } {
  global pvm_hostfile hostfile_buffer

  if {[catch {.generic.frame.tframe.text get 1.0 end} tmp] == 0} {
    set hostfile_buffer [.generic.frame.tframe.text get 1.0 end] }

  set fd [open $pvm_hostfile w+]
  if {$fd == -1} {
    error "Could not open $pvm_hostfile for reading & writing."
    SaveAsClickedCancel
    return }
  puts $fd $hostfile_buffer
  puts $fd "\n"
  close $fd
}

proc SaveAs { } {
  global hostfile_buffer

  set hostfile_buffer [.generic.frame.tframe.text get 1.0 end]
  file_window .generic SaveAsClickedOk SaveAsClickedCancel
}

proc Exit { } {
  exit
}

proc OpenClickedOK {name path} {
  global pvm_hostfile
  if {$path != ""} {
    set pvm_hostfile "$path/$name"
  } else {
    set pvm_hostfile "$name" 
  }

  set fd [open $pvm_hostfile a+]
  if {$fd == -1} {
    error "Could not open $pvm_hostfile for reading & writing."
    return }
  
  wm title . $pvm_hostfile
  PutText

  seek $fd 0 
  while {![eof $fd]} {
    .generic.frame.tframe.text insert end [read $fd 1000] }
  close $fd
}

proc SaveAsClickedOk {name path} {
  global pvm_hostfile hostfile_buffer
  if {$path != ""} {
    set pvm_hostfile "$path/$name"
  } else {
    set pvm_hostfile "$name" 
  }
  set fd [open $pvm_hostfile w+]
  if {$fd == -1} {
    error "Could not open $pvm_hostfile for reading and writing."
    SaveAsClickedCancel
    return
  }
  puts -nonewline $fd $hostfile_buffer
  close $fd
  OpenClickedOK $pvm_hostfile ""
}

proc OpenClickedCancel { } {
  global hostfile_buffer
  PutText
  .generic.frame.tframe.text insert end $hostfile_buffer
  .top.r3panel.onetest configure -state normal
  .top.r3panel.alltests configure -state normal
  .top.r3panel.allmsg configure -state normal
  .top.r3panel.allrtin configure -state normal
  .top.r3panel.fdat configure -state normal
  .top.r3panel.fndat configure -state normal
  .top.r3panel.hdat configure -state normal
  .top.r3panel.hndat configure -state normal
  .top.r3panel.tdat configure -state normal
  .top.r3panel.tndat configure -state normal
  .top.r3panel.bw configure -state normal
  .top.menu_bar.file configure -state normal
  .top.menu_bar.output configure -state normal
}

proc SaveAsClickedCancel { } {
  global hostfile_buffer
  PutText
  .generic.frame.tframe.text insert end $hostfile_buffer
}

proc MakeInFile { name output } {
  global errorCode hostfile_buffer all_comb_bool ttime_bool atime_bool atime_bool num_procs num_mesgs siz_mesgs bw_start bw_end bw_inc alltests allmsg allrtin fdat fndat hdat hndat tdat tndat bw onelabeltest

  exec rm -f $name
  if { $errorCode != "NONE" } {
    error "Could not remove $name."
    return 0 }

  set fd [open $name w]
  if { $fd == -1 } {
    error "Could not open $name for writing."
    return 0 }

  puts $fd "##########################################################################"
  puts $fd "#                   Input file of the pvm tester.                        #"
  puts $fd "#               To select tests put an 'x' between the two []              #"
  puts $fd "#	                    each time its needed.                        #"
  puts $fd "#              For further informations read the tester manual.          #"
  puts $fd "##########################################################################"
    
  set rest $hostfile_buffer
  set cur_index 0
  set did_something 0

  while { 1 } {
    set cr_nl_index [string first "\n" $rest]
    if {$cr_nl_index == -1} { break }
    set line [string trim [string range $rest 0 [expr $cr_nl_index-1]]]
    set first_char [string index $line 0]
    if {($line != "") && ($first_char != "#")} {
      puts $fd "config :$line"
      set did_something 1}
    set rest [string range $rest [expr $cr_nl_index+1] end] }

  if {!$did_something} {
    error "There are no names in your host file."
    close $fd
    exec rm -f $name
    return 0 }

  if {$all_comb_bool != 0} {
    puts $fd "all_combinations :1" }
  if {$ttime_bool != 0 } {
    puts $fd "total_timing :1" }
  if {$atime_bool != 0 } {
    puts $fd "average_timing :1" }

  puts $fd "funneling_proc :$num_procs"
  puts $fd "num_messages :$num_mesgs"
  puts $fd "messages_length :$siz_mesgs"

  puts $fd "#########parameters for test 43#########"
  puts $fd "start_length :$bw_start"
  puts $fd "max_length :$bw_end"
  puts $fd "incr :$bw_inc"
  puts $fd "outfile :$output"

  if {$onelabeltest != ""} {
      puts $fd "\[x]$onelabeltest" }
  if {$alltests != 0} {
      puts $fd "all_tests :1"}
  if {$allmsg != 0} {
      puts $fd "all_messaging :1" }
  if {$allrtin != 0} {
      puts $fd "all_routine :1" }
  if {$fndat != 0} {
      puts $fd "all_funnel_nodata :1" }
  if {$fdat != 0} {
      puts $fd "all_funnel_data :1" }
  if {$hndat != 0} {
      puts $fd "all_head_nodata :1" }
  if {$hdat != 0} {
      puts $fd "all_head_data :1" }
  if {$tndat != 0} {
      puts $fd "all_triangle_nodata :1" }
  if {$tdat != 0} {
      puts $fd "all_triangle_data :1" }
  if {$bw != 0} {
      puts $fd "all_perf :1" }
  close $fd
  return 1
}




proc bw_graph {} {
global pvm_test_pid

  if {[file readable /tmp/pt.d1.$pvm_test_pid] == 0} { return }
  if {[file readable /tmp/pt.d2.$pvm_test_pid] == 0} { return }

  set fd [open "/tmp/ptg.gnuplot.$pvm_test_pid" w]
  if {$fd < 0} {
    error "Could not create /tmp/ptg.gnuplot.$pvm_test_pid (GNUPLOT script file)"
    return 0 }

  puts $fd "set xlabel \"Number of bytes\""
  puts $fd "set ylabel \"Time in seconds\""
  puts $fd "set tics out"
  puts $fd "set data style linespoints"
  puts $fd "set autoscale"
  puts $fd "set term postscript landscape \"Times-Roman\" 14"
  puts $fd "set output \"/tmp/ptg.ps.$pvm_test_pid\""
  puts $fd "set title \"Bandwidth measurement from [exec hostname] on [exec date]\""
  puts $fd "plot \"/tmp/pt.d1.$pvm_test_pid\" using 1:2 title \"Measurement\" with lines 1 ,\"/tmp/pt.d2.$pvm_test_pid\" using 1:2 title \"Linear regression\" with lines 2"
  puts $fd "set yrange\[0.0001:0.001]"
  close $fd

  set retval [catch {exec gnuplot "/tmp/ptg.gnuplot.$pvm_test_pid" }]
  if {$retval != 0} {
    error "Could not run gnuplot: data saved in /tmp/pt.d1.$pvm_test_pid & /tmp/pt.d2.$pvm_test_pid; gnuplot script saved in /tmp/ptg.gnuplot.$pvm_test_pid"
    return 0 }

  set retval [catch {exec gs "/tmp/ptg.ps.$pvm_test_pid" >/dev/null 2>/dev/null &}]
  if {$retval != 0} {
    error "Could not run ghostscript to preview to graph" }
  exec rm -f /tmp/ptg.gnuplot.$pvm_test_pid /tmp/pt.d1.$pvm_test_pid /tmp/pt.d2.$pvm_test_pid /tmp/pt.ps.$pvm_test_pid
  return 1
}

proc PutTop { } {
frame .top 
pack .top -fill x
bind .top <Destroy> {
  exec rm -f /tmp/pt*$pvm_test_gui_pid }
}

#
# main()
#

PutTop
PutMenus 
PutHelp
PutGeneric .generic
PutSliders
PutActionButtons
PutCheckButtons

if {[catch {set pvm_root $env(PVM_ROOT)}]} {
  tkerror "You must set the PVM_ROOT environment variable."
  exit 1 }
if {[file executable $pvm_root/lib/pvmgetarch] == 0} {
  if {[catch {set pvm_arch $env(PVM_ARCH)}]} {
    tkerror "You must set the PVM_ARCH environment variable."
    exit 1 } 
  } else {
  set pvm_arch [exec $pvm_root/lib/pvmgetarch] }
if {[file executable ~/pvm3/bin/$pvm_arch/pvm_test] == 0} {
  tkerror "Could not find pvm_test in ~/pvm3/bin/$pvm_arch."
  exit 1 }
if {$argc == 1} {
  OpenClickedOK [lindex $argv 0] "" 
} elseif {$argc > 1} {
  puts stderr "Usage: $argv0 \[filename]"
  exit 1
} else {
  set pvm_hostfile "/tmp/ptg.hosts.$pvm_test_gui_pid"
  set f [open $pvm_hostfile w]
  if { $f == -1 } {
    tkerror "Could not create $pvm_hostfile." 
    exit 1 }
  puts $f "# This is your PVM host configuration file."
  puts $f [exec hostname]
  close $f
  OpenClickedOK $pvm_hostfile "" 
  wm title . $pvm_hostfile }
