#!/usr/bin/env python # Copyright (C) 2009 by Aaron Ariel, Wilson W. L. Fung, Tor M. Aamodt, Andrew # Turner and the University of British Columbia, Vancouver, # BC V6T 1Z4, All Rights Reserved. # # THIS IS A LEGAL DOCUMENT BY DOWNLOADING GPGPU-SIM, YOU ARE AGREEING TO THESE # TERMS AND CONDITIONS. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNERS OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # NOTE: The files libcuda/cuda_runtime_api.c and src/cuda-sim/cuda-math.h # are derived from the CUDA Toolset available from http://www.nvidia.com/cuda # (property of NVIDIA). The files benchmarks/BlackScholes/ and # benchmarks/template/ are derived from the CUDA SDK available from # http://www.nvidia.com/cuda (also property of NVIDIA). The files from # src/intersim/ are derived from Booksim (a simulator provided with the # textbook "Principles and Practices of Interconnection Networks" available # from http://cva.stanford.edu/books/ppin/). As such, those files are bound by # the corresponding legal terms and conditions set forth separately (original # copyright notices are left in files from these sources and where we have # modified a file our copyright notice appears before the original copyright # notice). # # Using this version of GPGPU-Sim requires a complete installation of CUDA # which is distributed seperately by NVIDIA under separate terms and # conditions. To use this version of GPGPU-Sim with OpenCL requires a # recent version of NVIDIA's drivers which support OpenCL. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # 3. Neither the name of the University of British Columbia nor the names of # its contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # 4. This version of GPGPU-SIM is distributed freely for non-commercial use only. # # 5. No nonprofit user may place any restrictions on the use of this software, # including as modified by the user, by any other authorized user. # # 6. GPGPU-SIM was developed primarily by Tor M. Aamodt, Wilson W. L. Fung, # Ali Bakhoda, George L. Yuan, at the University of British Columbia, # Vancouver, BC V6T 1Z4 import time import os import array import tkinter as Tk import matplotlib matplotlib.use('TkAgg') from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk from matplotlib.figure import Figure import matplotlib as mpl from matplotlib.colors import colorConverter from matplotlib import pyplot import Pmw import numpy import startup import lexyaccbookmark import copy import lexyacc import organizedata import lexyacctexteditor import variableclasses from configs import avconfig class formEntry: #This class is essentially a form placed inside a tab. It collects all the data from the user required for graphing. It then instantiates a new object that takes care of all the graphing graphForVarType = { 1:[0,3], 2:[0,3], 3:[4], 4:[0,3,5], 5:[6] } def __init__(self, graphTabs, numb, vars, res, entry): #Variable Initializations self.data = vars self.subBool = 0 self.possGraphs = ['Line', 'Histogram', 'Bar Chart', 'Parallel Intensity Plot', 'Stacked Bar Chart', 'Parallel Intensity Plot (Sum)', 'Scatter Plot'] self.res = res self.subplots = [] self.dataChosenX = "globalCycle" self.dataChosenY = "" self.dydx = 0 self.fileChosen = "" self.graphChosen = '' self.num = 0 #Setting a title to this tab if entry.get() == "TabTitle?": self.tabnum = "Page " + numb else: self.tabnum = entry.get() self.page = graphTabs.add(self.tabnum) #Size of the self.background depending on how large the user screen is if res == "small": self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 700, width = 1200); self.formArea = Tk.Frame(self.background, bg = "white") elif res == 'medium': self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); self.formArea = Tk.Frame(self.background, bg = "white") else: self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); self.formArea = Tk.Frame(self.background, bg = "white") chosenVars = Tk.Frame(self.background, bg = 'white') self.background.pack() # self.background.pack_propagate(0) self.formArea.pack(side = Tk.LEFT, anchor = Tk.N) chosenVars.pack(side = Tk.LEFT, anchor = Tk.N, padx = 15) # Frame and listboxes for choosing what file you want to use data from whichFileFrame = Tk.Frame(self.formArea, bg= 'white') whichFileFrame.pack(side = Tk.TOP, anchor = Tk.W, pady = 5) lwhichFileFrame = Tk.Label(whichFileFrame, text = 'Choose a File:', font = ("Gills Sans MT", 12), bg = "white") lwhichFileFrame.pack(side = Tk.LEFT) self.cWhichFile= Tk.Listbox(whichFileFrame, width = 85, height = 4) self.cWhichFile.pack(side =Tk.LEFT) self.cWhichFile.bind("", self.chooseFile) #Placing the available filenames in the self.cWhichFileFrame Listbox for files in sorted(self.data): self.cWhichFile.insert(Tk.END, files) # move to end of lines to actually see the filenames self.cWhichFile.xview_moveto(1) #Favourites Button self.bFavourites = Tk.Button(whichFileFrame, text = "Favourites", state = Tk.DISABLED, command = self.chooseFavourite ) self.bFavourites.pack(side = Tk.LEFT, padx = 5) #Frame for choosing what data you are going to plot chooseDataFrame = Tk.Frame(self.formArea, bg = "white") chooseDataFrame.pack(side = Tk.TOP, anchor = Tk.W) lchooseDataFrame = Tk.Label(chooseDataFrame, text= 'Data to be Plotted:', font = ("Gills Sans MT", 12), bg = "white") lchooseDataFrame.pack(side= Tk.LEFT); bQchooseDataFrameHelp = Tk.Button(chooseDataFrame, text = " ? -->", command = (lambda: self.helpMsg('Double-Click on the metric to select it for plotting.'))) bQchooseDataFrameHelp.pack(side =Tk.LEFT, padx = 5) XListbox = Tk.Frame(chooseDataFrame, bg= 'white') XListbox.pack(side = Tk.LEFT) XTitle = Tk.Label(XListbox, text = "X Vars", bg= 'white') XTitle.pack(side = Tk.TOP) self.cXAxisData = Tk.Listbox(XListbox, width = 19, height = 5, selectmode = Tk.MULTIPLE) self.cXAxisData.bind("", self.chooseDataX) YListbox = Tk.Frame(chooseDataFrame, bg = 'white') YListbox.pack(side = Tk.LEFT) YFrameForScrollbar = Tk.Frame(YListbox, bg= 'white') YFrameForScrollbar.pack(side = Tk.BOTTOM) scrollYAxisData = Tk.Scrollbar(YFrameForScrollbar, orient = Tk.VERTICAL) YTitle = Tk.Label(YListbox, text = 'Y Vars', bg= 'white') YTitle.pack(side = Tk.TOP) self.cYAxisData = Tk.Listbox(YFrameForScrollbar,width = 19, height = 5, yscrollcommand=scrollYAxisData.set) self.cYAxisData.bind("", self.chooseDataY) scrollYAxisData.config(command=self.cYAxisData.yview) self.cXAxisData.pack(side = Tk.BOTTOM) self.cYAxisData.pack(side = Tk.LEFT) scrollYAxisData.pack(side=Tk.LEFT, fill = 'y') # The Take Derivative Checkbutton self.var0 = Tk.IntVar() checkbDyDx = Tk.Checkbutton(chooseDataFrame, text= "dy/dx", variable= self.var0, bg = 'white', command = (lambda: self.checkDyDx())) checkbDyDx.pack(side= Tk.LEFT, padx = 5) #Frame for choosing what type of graph typeGraph = Tk.Frame(self.formArea, bg = "white") typeGraph.pack(side = Tk.TOP, anchor = Tk.W, pady = 10) lTypeGraph = Tk.Label(typeGraph, text= 'Type of Graph:', font = ("Gills Sans MT", 12), bg = "white") lTypeGraph.pack(side= Tk.LEFT); bQTypeGraphHelp = Tk.Button(typeGraph, text = " ? -->", command = (lambda: self.helpMsg('Double-Click on the graph type to select it.'))) bQTypeGraphHelp.pack(side =Tk.LEFT, padx = 5) self.cTypeGraph = Tk.Listbox(typeGraph, width = 50, height = 3) self.cTypeGraph.bind("", self.chooseGraph) self.cTypeGraph.pack(side = Tk.LEFT) subplotWindow = Tk.Frame(self.formArea, bg = "white") subplotWindow.pack(side = Tk.TOP, anchor = Tk.W) lSubplot = Tk.Label(subplotWindow, bg = "white", text = "Add Subplot:", font = ("Gills Sans MT", 12)) lSubplot.pack(side =Tk.LEFT, anchor = Tk.N) lnumSubplot = Tk.Label(subplotWindow, bg= 'white', text= "# Subplots -") lnumSubplot.pack(side = Tk.LEFT, anchor = Tk.S) subplotSlider = Tk.Scale(subplotWindow, from_=1, to=5, orient = Tk.HORIZONTAL, bg= 'white') subplotSlider.pack(side = Tk.LEFT, anchor = Tk.N) bSubplotSlider = Tk.Button(subplotWindow, text = "Submit", command = lambda: (self.addSubplot(subplotSlider.get()))) bSubplotSlider.pack(side = Tk.LEFT) bcancelSubplot = Tk.Button(subplotWindow, text= "Cancel", command = lambda: self.removeSubplotWindow()) bcancelSubplot.pack(side = Tk.LEFT) #Button for graphing graphButton = Tk.Frame(chosenVars, bg = "white") graphButton.pack(side = Tk.TOP, fill = Tk.X) bGraphButton = Tk.Button(graphButton,borderwidth = 5, bg = 'green', text = "GraphMe!",font = ("Gills Sans MT", 14), command = (lambda: self.setupPlotData())) bGraphButton.pack(side = Tk.RIGHT, pady = 5) #Frame that will have the textbox that lists everything the user has chosen to do ChosenVarsTitle = Tk.Label(chosenVars, text = 'Options Chosen', font = ("Gills Sans MT", 12), bg = "white") ChosenVarsTitle.pack(side = Tk.TOP) innerChosenVarsFrame = Tk.Frame(chosenVars, bg= 'white') innerChosenVarsFrame.pack(side = Tk.TOP, pady = 10, fill = Tk.Y) ChosenVarsTextboxScrollbar = Tk.Scrollbar(innerChosenVarsFrame, orient = Tk.VERTICAL) ChosenVarsTextboxScrollbar.pack(side = Tk.RIGHT, fill = Tk.Y) self.ChosenVarsTextbox = Tk.Text(innerChosenVarsFrame, height = 41, width = 45, yscrollcommand = ChosenVarsTextboxScrollbar.set) self.ChosenVarsTextbox.pack(fill = Tk.Y) ChosenVarsTextboxScrollbar.config(command = self.ChosenVarsTextbox.yview) #Setting up subplot stuff self.subplotWindow = Tk.Frame(self.formArea, bg='green', height = 300, width = 700) self.subplotWindow.pack(side = Tk.TOP, pady = 10) self.subplotWindow.pack_propagate(0) self.subplotTabs = Pmw.NoteBook(self.subplotWindow) self.subplotTabs.pack(fill='both',expand = 'True') tmpInnerSubplotWindow = self.subplotTabs.add('No Subplots Chosen Yet') tmpInnerSubplotWindow.pack() tmpInnerSubplotWindow1 = Tk.Frame(tmpInnerSubplotWindow, bg = 'white', height = 300, width = 300) tmpInnerSubplotWindow1.pack(fill = 'both') tmpInnerSubplotWindow1.pack_propagate(0) tmpInnerSubplotWindow1Title = Tk.Label(tmpInnerSubplotWindow1, text = 'You have not chosen to have any subplots', bg= 'white') tmpInnerSubplotWindow1Title.pack() self.updateChosen() def chooseFile(self, *event): try: self.bFavourites.config( state = Tk.NORMAL ) except: pass self.fileChosen = self.cWhichFile.get('active') #Initialize both 'cXAxisData' and 'self.cYAxisData' to empty listboxes self.cXAxisData.delete(0, Tk.END) self.cYAxisData.delete(0, Tk.END) #filling in xAxis vars for keys in list(self.data[self.fileChosen].keys()): if keys == 'globalCycle': self.cXAxisData.insert(Tk.END, keys) #filling in yAxis vars #Need to fill up list alphabetically keysAlpha = [] for key in list(self.data[self.fileChosen].keys()): if key not in ['globalCycle','CFLOG','EXTVARS']:#exclude hacks from list keysAlpha.append(key) #keysAlpha.sort(key=lambda x, y: cmp(x.lower(),y.lower())) for keys in keysAlpha: self.cYAxisData.insert(Tk.END, keys) self.updateChosen() def chooseDataX(self, *event): self.dataChosenX = self.cXAxisData.get('active') self.cTypeGraph.delete(0,Tk.END) if ((self.dataChosenX != "") and (self.dataChosenY != "")): if self.data[self.fileChosen][self.dataChosenY].type == 1 or self.data[self.fileChosen][self.dataChosenY].type == 2 or self.data[self.fileChosen][self.dataChosenY].type == 4: self.cTypeGraph.insert(Tk.END, self.possGraphs[0]) self.cTypeGraph.insert(Tk.END, self.possGraphs[3]) else: self.cTypeGraph.insert(Tk.END, self.possGraphs[4]) self.updateChosen() def chooseDataY(self, *event): self.dataChosenY = self.cYAxisData.get('active') self.cTypeGraph.delete(0,Tk.END) if ((self.dataChosenX != "") and (self.dataChosenY != "")): varType = self.data[self.fileChosen][self.dataChosenY].type for g in formEntry.graphForVarType[varType]: self.cTypeGraph.insert(Tk.END, self.possGraphs[g]) #if self.data[self.fileChosen][self.dataChosenY].type == 1 or self.data[self.fileChosen][self.dataChosenY].type == 2: # self.cTypeGraph.insert(Tk.END, self.possGraphs[0]) # self.cTypeGraph.insert(Tk.END, self.possGraphs[3]) #elif self.data[self.fileChosen][self.dataChosenY].type == 4: # self.cTypeGraph.insert(Tk.END, self.possGraphs[0]) # self.cTypeGraph.insert(Tk.END, self.possGraphs[3]) # self.cTypeGraph.insert(Tk.END, self.possGraphs[5]) #else: # self.cTypeGraph.insert(Tk.END, self.possGraphs[4]) self.updateChosen() def checkDyDx(self): self.dydx = self.var0.get() self.updateChosen() def chooseGraph(self,num): self.graphChosen = self.cTypeGraph.get('active') self.updateChosen() def updateChosen(self): self.ChosenVarsTextbox.tag_config('title', font = ("Gills Sans MT", 12), justify = 'center', spacing1 = 0.5, underline = 1) self.ChosenVarsTextbox.tag_config('complete', background = 'green') self.ChosenVarsTextbox.tag_config('incomplete', background= 'red') if self.dydx == 1: check = 'YES' else: check = 'NO' if self.num == 0: self.ChosenVarsTextbox.delete(0.0, Tk.END) self.ChosenVarsTextbox.insert(Tk.END, 'Plot: \n', ("title")) if self.fileChosen == '': self.ChosenVarsTextbox.insert(Tk.END, 'FileChosen: ' + self.fileChosen + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'FileChosen: ' + self.fileChosen + '\n', ('complete')) if self.dataChosenX == '': self.ChosenVarsTextbox.insert(Tk.END, 'XAxis: ' + self.dataChosenX + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'XAxis: ' + self.dataChosenX + '\n', ('complete')) if self.dataChosenY == '': self.ChosenVarsTextbox.insert(Tk.END, 'YAxis: ' + self.dataChosenY + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'YAxis: ' + self.dataChosenY + '\n', ('complete')) if self.graphChosen == '': self.ChosenVarsTextbox.insert(Tk.END, 'graphChosen: ' + self.graphChosen + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'graphChosen: ' + self.graphChosen + '\n', ('complete')) self.ChosenVarsTextbox.insert(Tk.END, 'dydx: ' + check + '\n') else: if self.ChosenVarsTextbox.search('Subplot0', index = 0.0) != '': self.ChosenVarsTextbox.delete(self.ChosenVarsTextbox.search('Subplot0', index = 0.0), Tk.END) for iter in self.subplots: if iter.dydx == 1: check = 'YES' else: check = 'NO' self.ChosenVarsTextbox.insert(Tk.END, '\n') self.ChosenVarsTextbox.insert(Tk.END, 'Subplot' + str(self.subplots.index(iter)) + ': \n', ("title")) if iter.fileChosen == '': self.ChosenVarsTextbox.insert(Tk.END, 'FileChosen: ' + iter.fileChosen + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'FileChosen: ' + iter.fileChosen + '\n', ('complete')) if iter.dataChosenX == '': self.ChosenVarsTextbox.insert(Tk.END, 'XAxis: ' + iter.dataChosenX + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'XAxis: ' + iter.dataChosenX + '\n', ('complete')) if iter.dataChosenY == '': self.ChosenVarsTextbox.insert(Tk.END, 'YAxis: ' + iter.dataChosenY + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'YAxis: ' + iter.dataChosenY + '\n', ('complete')) if iter.graphChosen == '': self.ChosenVarsTextbox.insert(Tk.END, 'graphChosen: ' + iter.graphChosen + '\n', ('incomplete')) else: self.ChosenVarsTextbox.insert(Tk.END, 'graphChosen: ' + iter.graphChosen + '\n', ('complete')) self.ChosenVarsTextbox.insert(Tk.END, 'dydx: ' + check + '\n') def addSubplot(self, subNum): self.removeSubplotWindow() self.subplots = [] if self.subBool == 1: pass else: self.subplotTabs.delete(Pmw.SELECT) subplotFrames = [] for subplotForms in range(0,subNum): subplotFrames.append(self.subplotTabs.add('Subplot' + str(subplotForms))) self.subplots.append(subplotInstance(subplotFrames[-1], self.data, self, subplotForms + 1)) self.updateChosen() def modSubplot(self, oldNum, subNum): if (oldNum > subNum): #trucate self.subplots = self.subplots[:subNum] return if (oldNum == subNum): #nothing needs doing return if (oldNum > 0): #some subplots have been specified add remaining for subplotForms in range(oldNum,subNum): subplotFrames = [] subplotFrames.append(self.subplotTabs.add('Subplot' + str(subplotForms))) self.subplots.append(subplotInstance(subplotFrames[-1], self.data, self, subplotForms + 1)) self.updateChosen() return #there are no subplots, add them: self.removeSubplotWindow() self.subplots = [] self.subplotTabs.delete(Pmw.SELECT) subplotFrames = [] for subplotForms in range(0,subNum): subplotFrames.append(self.subplotTabs.add('Subplot' + str(subplotForms))) self.subplots.append(subplotInstance(subplotFrames[-1], self.data, self, subplotForms + 1)) self.updateChosen() def removeSubplotWindow(self): self.subplotWindow.destroy() #Setting up subplot stuff self.subplotWindow = Tk.Frame(self.formArea, bg='green', height = 300, width = 700) self.subplotWindow.pack(side = Tk.TOP, pady = 10) self.subplotWindow.pack_propagate(0) self.subplotTabs = Pmw.NoteBook(self.subplotWindow) self.subplotTabs.pack(fill='both',expand = 'True') tmpInnerSubplotWindow = self.subplotTabs.add('No Subplots Chosen Yet') tmpInnerSubplotWindow.pack() tmpInnerSubplotWindow1 = Tk.Frame(tmpInnerSubplotWindow, bg = 'white', height = 300, width = 300) tmpInnerSubplotWindow1.pack(fill = 'both') tmpInnerSubplotWindow1.pack_propagate(0) tmpInnerSubplotWindow1Title = Tk.Label(tmpInnerSubplotWindow1, text = 'You have not chosen to have any subplots', bg= 'white') tmpInnerSubplotWindow1Title.pack() self.subplots = [] self.updateChosen() def setupPlotData(self): bool = 1 error = 0 for iter in self.subplots: if iter.dataChosenX == '' or iter.dataChosenY == '' or iter.graphChosen == '' or iter.fileChosen == '': bool = 0 error = 1 if self.dataChosenX == '' or self.dataChosenY == '' or self.graphChosen == '' or self.fileChosen == '': bool = 0 error = 1 if error == 1: self.errorMsg('You must choose from all fields before you may graph') if bool == 1: self.background.destroy() self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); self.background.pack() self.background.pack_propagate(0) THEGRAPH = graphManager(self.background, self.data, self.res, [self, self.subplots]) def favouriteDescription(self): self.tDescription.delete(1.0, Tk.END) favouriteChosen = self.cFavourites.get('active') for count in range(0,len(self.bookmarks)): if favouriteChosen == self.bookmarks[count].title: bookmarkNum = count description = self.bookmarks[bookmarkNum].description self.tDescription.insert(1.0, description ) def chooseFavourite(self): self.favouriteWindow = Tk.Toplevel(bg = 'white') self.favouriteWindow.title("Favourites") above = Tk.Frame(self.favouriteWindow, bg = 'white') above.pack(side = Tk.TOP, padx = 100) topLabel = Tk.Label(above, text = "Available Options", font = ("Gills Sans MT", 20, "underline", "bold"), bg = 'white') topLabel.pack(pady = 20, padx = 20) subLabel = Tk.Label(above, text = "*Note: to display favourites that have subplots, you must first choose a subplot file", bg = 'white') subLabel.pack(side = Tk.TOP, padx = 20) subLabel1 = Tk.Label(above, text = "*Currently only displaying favourites that are composed of " + str(len(self.subplots) + 1) + ' plots', bg = 'white') subLabel1.pack(side = Tk.TOP, padx = 20) listboxFrames = Tk.Frame(self.favouriteWindow, bg = 'white') listboxFrames.pack(side = Tk.TOP, anchor = Tk.W) self.cFavourites = Tk.Listbox(listboxFrames, width = 30, height = 10) self.cFavourites.pack(side = Tk.LEFT, padx = 20, pady = 20) self.cFavourites.bind("", self.chooseFavourites1) bDescription = Tk.Button(listboxFrames, text = "Description -->", command = self.favouriteDescription) bDescription.pack(side = Tk.LEFT) self.tDescription = Tk.Text(listboxFrames, bg = 'white', width = 50, height = 10) self.tDescription.pack(side = Tk.LEFT, padx = 20) self.bQuit = Tk.Button(self.favouriteWindow, text= "Quit Window", command = (lambda: self.favouriteWindow.destroy())) self.bQuit.pack(side = Tk.TOP, padx = 10, pady = 10) self.bookmarks = lexyaccbookmark.parseMe() for iter in self.bookmarks: #if len(iter.graphChosen) == len(self.subplots) + 1: # bool = 1 # if len(self.subplots) > 0: # for iter1 in self.subplots: # if iter1.fileChosen == "": # iter1.fileCosen = self.fileChosen # else: # bool = 1 # if bool == 1: # self.cFavourites.insert(Tk.END, iter.title) self.cFavourites.insert(Tk.END, iter.title) def chooseFavourites1(self, *event): self.favouriteChosen = self.cFavourites.get('active') for count in range(0,len(self.bookmarks)): if self.favouriteChosen == self.bookmarks[count].title: bookmarkNum = count self.dataChosenX = self.bookmarks[bookmarkNum].dataChosenX[0] self.dataChosenY = self.bookmarks[bookmarkNum].dataChosenY[0] self.graphChosen = self.bookmarks[bookmarkNum].graphChosen[0] self.dydx = int(self.bookmarks[bookmarkNum].dydx[0]) self.modSubplot(len(self.subplots),len(self.bookmarks[bookmarkNum].graphChosen)-1) if self.subplots > 0: for iter in range(0, len(self.subplots)): if self.subplots[iter].fileChosen == '': self.subplots[iter].fileChosen = self.fileChosen self.subplots[iter].dataChosenX = self.bookmarks[bookmarkNum].dataChosenX[iter+1] self.subplots[iter].dataChosenY = self.bookmarks[bookmarkNum].dataChosenY[iter+1] self.subplots[iter].graphChosen = self.bookmarks[bookmarkNum].graphChosen[iter+1] self.subplots[iter].dydx = int(self.bookmarks[bookmarkNum].dydx[iter+1]) self.favouriteWindow.destroy() self.background.destroy() self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); self.background.pack() self.background.pack_propagate(0) THEGRAPH = graphManager(self.background, self.data, self.res, [self, self.subplots]) def errorMsg(self, string): error = Tk.Toplevel(bg = 'white') error.title("Error Message") tError = Tk.Label(error, text = "Error", font = ("Gills Sans MT", 20, "underline", "bold"), bg = "red") tError.pack(side = Tk.TOP, pady = 20) lError = Tk.Label(error, text = string, font = ("Gills Sans MT", 15, "bold"), bg = 'white') lError.pack(pady = 10, padx = 10) bError = Tk.Button(error, text = "OK", font = ("Times New Roman", 14), command = (lambda: error.destroy())) bError.pack(pady = 10) def helpMsg(self, string): helpTip = Tk.Toplevel(bg = 'white') helpTip.title("Helping Tip") lHelpTip = Tk.Label(helpTip, text = string, font = ("Gills Sans MT", 15, "bold"), bg = 'white') lHelpTip.pack(pady = 10, padx = 10) bHelpTip = Tk.Button(helpTip, text = "OK", font = ("Times New Roman", 14), command = (lambda: helpTip.destroy())) bHelpTip.pack(pady = 10) class subplotInstance(formEntry): def __init__(self, master,data,plotInstance, subNum): frame = Tk.Frame(master, width = 700, height = 300, bg ='white') frame.pack() frame.pack_propagate(0) #Variable Initializations self.fileChosen = '' self.dataChosenX = 'globalCycle' self.dataChosenY = '' self.graphChosen = '' self.data = data self.var0 = Tk.IntVar() self.possGraphs = ['Line', 'Histogram', 'Bar Chart', 'Parallel Intensity Plot', 'Stacked Bar Chart', 'Parallel Intensity Plot (Sum)', 'Scatter Plot'] self.dydx = 0 self.ChosenVarsTextbox = plotInstance.ChosenVarsTextbox self.num = subNum self.subplots = plotInstance.subplots # Frame and listboxes for choosing what file you want to use data from whichFileFrame = Tk.Frame(frame, bg= 'white') whichFileFrame.pack(side = Tk.TOP, anchor = Tk.W, pady = 5) lwhichFileFrame = Tk.Label(whichFileFrame, text = 'Choose a File:', font = ("Gills Sans MT", 12), bg = "white") lwhichFileFrame.pack(side = Tk.LEFT) self.cWhichFile= Tk.Listbox(whichFileFrame, width = 85, height = 4) self.cWhichFile.pack(side =Tk.LEFT) self.cWhichFile.bind("", self.chooseFile) #Placing the available filenames in the self.cWhichFileFrame Listbox for files in sorted(self.data): self.cWhichFile.insert(Tk.END, files) # move to end of lines to actually see the filenames self.cWhichFile.xview_moveto(1) #Frame for choosing what data you are going to plot chooseDataFrame = Tk.Frame(frame, bg = "white") chooseDataFrame.pack(side = Tk.TOP, anchor = Tk.W) lchooseDataFrame = Tk.Label(chooseDataFrame, text= 'Data to be Plotted:', font = ("Gills Sans MT", 12), bg = "white") lchooseDataFrame.pack(side= Tk.LEFT); bQchooseDataFrameHelp = Tk.Button(chooseDataFrame, text = " ? -->", command = (lambda: self.helpMsg('Double-Click on the metric to select it for plotting.'))) bQchooseDataFrameHelp.pack(side =Tk.LEFT, padx = 5) XListbox = Tk.Frame(chooseDataFrame, bg= 'white') XListbox.pack(side = Tk.LEFT) XTitle = Tk.Label(XListbox, text = "X Vars", bg= 'white') XTitle.pack(side = Tk.TOP) self.cXAxisData = Tk.Listbox(XListbox, width = 19, height = 5, selectmode = Tk.MULTIPLE) self.cXAxisData.bind("", self.chooseDataX) YListbox = Tk.Frame(chooseDataFrame, bg = 'white') YListbox.pack(side = Tk.LEFT) YFrameForScrollbar = Tk.Frame(YListbox, bg= 'white') YFrameForScrollbar.pack(side = Tk.BOTTOM) scrollYAxisData = Tk.Scrollbar(YFrameForScrollbar, orient = Tk.VERTICAL) YTitle = Tk.Label(YListbox, text = 'Y Vars', bg= 'white') YTitle.pack(side = Tk.TOP) self.cYAxisData = Tk.Listbox(YFrameForScrollbar,width = 19, height = 5, yscrollcommand=scrollYAxisData.set) self.cYAxisData.bind("", self.chooseDataY) scrollYAxisData.config(command=self.cYAxisData.yview) self.cXAxisData.pack(side = Tk.BOTTOM) self.cYAxisData.pack(side = Tk.LEFT) scrollYAxisData.pack(side=Tk.LEFT, fill = 'y') # The Take Derivative Checkbutton self.var0 = Tk.IntVar() checkbDyDx = Tk.Checkbutton(chooseDataFrame, text= "dy/dx", variable= self.var0, bg = 'white', command = (lambda: self.checkDyDx())) checkbDyDx.pack(side= Tk.LEFT, padx = 5) #Frame for choosing what type of graph typeGraph = Tk.Frame(frame, bg = "white") typeGraph.pack(side = Tk.TOP, anchor = Tk.W, pady = 10) lTypeGraph = Tk.Label(typeGraph, text= 'Type of Graph:', font = ("Gills Sans MT", 12), bg = "white") lTypeGraph.pack(side= Tk.LEFT); bQTypeGraphHelp = Tk.Button(typeGraph, text = " ? -->", command = (lambda: self.helpMsg('Double-Click on the graph type to select it.'))) bQTypeGraphHelp.pack(side =Tk.LEFT, padx = 5) self.cTypeGraph = Tk.Listbox(typeGraph, width = 50, height = 3) self.cTypeGraph.bind("", self.chooseGraph) self.cTypeGraph.pack(side = Tk.LEFT) # Class holding all the format information of a plot class PlotFormatInfo: # names of available colormaps cmapOptions = ['gist_heat_r', 'gist_heat', 'hot_r', 'hot', 'gray', 'gray_r', 'spectral', 'bone', 'bone_r', 'GnBu', 'GnBu_r', 'gist_earth', 'gist_earth_r', 'zero_dark', 'zero_white'] # custom color maps zero_dark = {'red': ((0.0, 0.0, 0.0), (0.0001, 1.0, 1.0), (1.0, 0.0, 1.0)), 'green':((0.0, 0.0, 0.0), (0.0001, 0.0, 0.0), (0.5, 1.0, 1.0), (1.0, 0.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (0.0001, 0.0, 0.0), (0.25, 0.0, 0.0), (1.0, 1.0, 1.0))} zero_dark_cmap = mpl.colors.LinearSegmentedColormap('zero_dark', zero_dark, 1024) zero_white = {'red': ((0.0, 1.0, 1.0), (0.0001, 1.0, 1.0), (1.0, 0.0, 1.0)), 'green':((0.0, 1.0, 1.0), (0.0001, 1.0, 0.0), (0.5, 1.0, 1.0), (1.0, 0.0, 1.0)), 'blue': ((0.0, 1.0, 1.0), (0.0001, 1.0, 0.0), (0.25, 0.0, 0.0), (1.0, 1.0, 1.0))} zero_white_cmap = mpl.colors.LinearSegmentedColormap('zero_white', zero_white, 1024) custom_cmaps = {'zero_dark': zero_dark_cmap, 'zero_white': zero_white_cmap } strNoDisplay = 'NULL:0x0000' optionSection = 'TimeLapseView' def __init__(self, plotID, title = strNoDisplay, xlabel = strNoDisplay, ylabel = strNoDisplay, cbarlabel = strNoDisplay, rotation = avconfig.get_value(optionSection, 'xTicksRotation', 'horizontal'), labelFontSize = avconfig.get_value(optionSection, 'labelFontSize', 13), cticksFontSize = avconfig.get_value(optionSection, 'cTicksFontSize', 10), xticksFontSize = avconfig.get_value(optionSection, 'xTicksFontSize', 10), yticksFontSize = avconfig.get_value(optionSection, 'yTicksFontSize', 10)): self.plotID = plotID # for debugging purpose self.title = title self.xlabel = xlabel self.ylabel = ylabel self.cbarlabel = cbarlabel self.rotation = rotation self.labelFontSize = labelFontSize self.cticksFontSize = cticksFontSize self.xticksFontSize = xticksFontSize self.yticksFontSize = yticksFontSize self.cmap = Tk.StringVar() self.cmap.set(PlotFormatInfo.cmapOptions[0]) self.norm = mpl.colors.Normalize() def InitLabels(self, xlabel, ylabel, cbarlabel, title = ''): if (self.xlabel == PlotFormatInfo.strNoDisplay): self.xlabel = xlabel if (self.ylabel == PlotFormatInfo.strNoDisplay): self.ylabel = ylabel if (self.cbarlabel == PlotFormatInfo.strNoDisplay): self.cbarlabel = cbarlabel if (self.title == PlotFormatInfo.strNoDisplay): self.title = title # Obtain the matplotlib colormap that will be used for the parallel intensity plot def GetColorMap(self): cmapName = self.cmap.get() if (cmapName in PlotFormatInfo.custom_cmaps): cmap = PlotFormatInfo.custom_cmaps[cmapName] else: cmap = mpl.cm.get_cmap(name=cmapName) return cmap class graphManager: def __init__(self, master, data, res, dataChosen): self.normalizePlotColors = '' self.master = master #Variable initializations self.cycleStep = 0 self.wilLeft = '' self.res =res self.dataChosen = dataChosen self.data = data self.disconnect = 0 self.possGraphs = ['Line', 'Histogram', 'Bar Chart', 'Parallel Intensity Plot', 'Stacked Bar Chart', 'Parallel Intensity Plot (Sum)', 'Scatter Plot'] self.xlim = 0 self.xAxisStepsWilStack = {} self.cbarAxes = {} self.plotRef = {} self.plotFormatInfo = {} self.displayData = {} if self.res == "small": self.underneathGraph = Tk.Frame(master, borderwidth = 5, relief = Tk.GROOVE, height = 100, width = 1225); elif self.res == 'medium': self.underneathGraph = Tk.Frame(master, borderwidth = 5, relief = Tk.GROOVE, height = 100, width = 1572); else: self.underneathGraph = Tk.Frame(master, borderwidth = 5, relief = Tk.GROOVE, height = 100, width = 1572); self.underneathGraph.pack(side = Tk.BOTTOM, fill = Tk.X ) if self.res == "small": self.graphArea = Tk.Canvas(master, bg = "black", borderwidth = 5, relief = Tk.GROOVE, width = 1200); elif self.res == 'medium': self.graphArea = Tk.Canvas(master, bg = "black", borderwidth = 5, relief = Tk.GROOVE, width = 1513, height = 800); else: self.graphArea = Tk.Canvas(master, bg = "black", borderwidth = 5, relief = Tk.GROOVE, width = 1513, height = 800); self.graphArea.pack(side = Tk.BOTTOM, fill = Tk.BOTH, expand = 1) ## Allow user to choose specific graph options self.leftMostUnderneath = Tk.Frame(self.underneathGraph); self.leftMostUnderneath.pack(side = Tk.LEFT, anchor = Tk.N) self.toolbarArea = Tk.Frame(self.leftMostUnderneath, borderwidth = 1, relief = Tk.GROOVE, bg = 'black') self.toolbarArea.pack(anchor = Tk.N) bDyDx = Tk.Button(self.underneathGraph, text = 'dy/dx', command = self.takeDerivativeButton) bDyDx.pack(side = Tk.RIGHT, anchor = Tk.N) bAddToFavourites = Tk.Button(self.underneathGraph, text = "Add to Favourites", command = self.addToFavourites) bAddToFavourites.pack(side = Tk.RIGHT, anchor = Tk.N) bRefreshInputFiles = Tk.Button(self.underneathGraph, text= "Refresh Input Files", command = self.refreshInputs) bRefreshInputFiles.pack(side = Tk.RIGHT, anchor = Tk.N) bChangeColorMapMaxMin = Tk.Button(self.underneathGraph, text = "Change Colormap Max/Min", command = self.changeColorMapMaxMin) bChangeColorMapMaxMin.pack(side = Tk.RIGHT, anchor = Tk.N) bChangeBinning = Tk.Button(self.underneathGraph, text = 'Change Binning', command = self.changeBinning) bChangeBinning.pack(side = Tk.RIGHT, anchor = Tk.N) bEditLabels = Tk.Button(self.underneathGraph, text = 'Edit Labels', command = self.editLabelsButton) bEditLabels.pack(side = Tk.RIGHT, anchor = Tk.N) bZoom = Tk.Button(self.underneathGraph, text = 'Zoom', command = self.zoomButton) bZoom.pack(side = Tk.RIGHT, anchor = Tk.N) if self.res == "small": self.figure = Figure(figsize=(17,9), dpi=96) elif self.res == 'medium': self.figure = Figure(figsize=(20,9), dpi=96) else: self.figure = Figure(figsize=(22,13), dpi=96) #self.plot = self.figure.add_subplot(111) self.canvas = FigureCanvasTkAgg(self.figure, master=self.graphArea) self.canvas.get_tk_widget().pack() self.toolbar = NavigationToolbar2Tk(self.canvas, self.toolbarArea) self.toolbar.update() self.plotData() def addToFavourites(self): self.addFavourite = Tk.Toplevel(bg = 'white') self.addFavourite.title("Add Favourite") fTitle = Tk.Frame(self.addFavourite, bg = 'white') fTitle.pack(side = Tk.TOP, padx= 100, pady = 10) lTitle = Tk.Label(fTitle, text = "Title of new favourite: ", bg = 'white') lTitle.pack(side = Tk.LEFT) self.eTitle = Tk.Entry(fTitle, width = 50, bg = 'white') self.eTitle.pack(side = Tk.LEFT, padx = 3) fDescription = Tk.Frame(self.addFavourite, bg = 'white') fDescription.pack(side = Tk.TOP, padx= 100, pady = 10) lDescription = Tk.Label(fDescription, text = "Description of favourite: ", bg = 'white') lDescription.pack(side = Tk.LEFT) self.eDescription = Tk.Text(fDescription, width = 50, height = 10, bg = 'white') self.eDescription.pack(side = Tk.LEFT) fSubCanc = Tk.Frame(self.addFavourite, bg = 'white') fSubCanc.pack(side = Tk.BOTTOM) bSubmit = Tk.Button(fSubCanc, text = "Submit", command = self.addFavouriteTitDesc) bSubmit.pack(side = Tk.LEFT) bCancel = Tk.Button(fSubCanc, text = "Cancel", command = (lambda: self.addFavourite.destroy())) def addFavouriteTitDesc(self): bool = 1 self.favouriteTitle = self.eTitle.get() self.favouriteDesc = self.eDescription.get(1.0,Tk.END) self.favouriteDesc = str(self.favouriteDesc) test = [] test.append(self.favouriteDesc) self.addFavourite.destroy() self.favouriteDesc = self.favouriteDesc.rstrip() test.append(self.favouriteDesc) if self.favouriteTitle == "": self.errorMsg("You need to at least submit a title, try again...") bool = 0 numPlots = len(self.dataChosen[1]) + 1 self.dataPointer = self.dataChosen[0] if bool: file = open(os.environ['HOME'] + "/.gpgpu_sim/aerialvision/bookmarks.txt", 'a') file.write('START = "TRUE"\n') file.write('title = "' + self.favouriteTitle + '"\n') file.write('description = "' + self.favouriteDesc + '"\n') for self.currPlot in range(1,numPlots + 1): file.write('dataChosenX = "' + self.dataPointer.dataChosenX + '"\n') file.write('dataChosenY = "' + self.dataPointer.dataChosenY + '"\n') file.write('graphChosen = "' + self.dataPointer.graphChosen + '"\n') file.write('dydx = "' + str(self.dataPointer.dydx) + '"\n') if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] file.close() def format_coordWilson(self, x, y): col = int(x)*(self.simplerName[self.dataPointer.dataChosenX].data[1]) row = int(y+0.5) numrows = len(self.simplerName[self.dataPointer.dataChosenY].data) try: numcols = len(self.simplerName[self.dataPointer.dataChosenY].data[0]) except: numcols = 1 if x>=0 and x=0 and y self.xlim: self.xlim = tmp[-1] self.cycleStep = tmp[1] else: pass if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] # initialize format info of this plot if self.currPlot not in self.plotFormatInfo: self.plotFormatInfo[self.currPlot] = PlotFormatInfo(self.currPlot) self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() if (self.currPlot in self.plotRef): self.figure.delaxes(self.plotRef[self.currPlot]) self.plot = self.figure.add_subplot(numPlots,1,self.currPlot) self.plotRef[self.currPlot] = self.plot self.plotFormatInfo[self.currPlot].graphType = self.dataPointer.graphChosen if self.dataPointer.graphChosen == 'Parallel Intensity Plot': self.plot.format_coord = self.format_coordWilson yDataType = self.simplerName[self.dataPointer.dataChosenY].type if yDataType == 1: self.type1Variable(self.simplerName[self.dataPointer.dataChosenX].data , self.dataPointer.dataChosenX, self.simplerName[self.dataPointer.dataChosenY].data, self.dataPointer.dataChosenY, self.simplerName[self.dataPointer.dataChosenY].bool, self.currPlot) elif yDataType == 2: self.type2Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX, self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) elif yDataType == 3: self.type3Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX,self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) elif yDataType == 4: self.type4Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX,self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) elif yDataType == 5: self.type5Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX,self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) else: raise Exception("Unknown data type!\n") if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] #self.figure.subplots_adjust(top = 0.80) def type1Variable(self, x, xAxis, y, yAxis, boolK, plotID): graphOption = 'NULL' if ('globalTotInsn' in self.simplerName) == 'False': graphOption = 1 if (graphOption == 1): if (self.dataPointer.dydx >= 1): for iter in range(0, self.dataPointer.dydx): y = self.takeDerivative(x, y) yAxis = yAxis + '/Cycle' if (self.graphChosen == self.possGraphs[3]): self.plotParallelIntensity(x, xAxis, [y], yAxis, yAxis, [1], plotID) else: self.plot2VarLine(x, xAxis, y, yAxis) else: x = self.updateVarKernal(x) if boolK: y = self.updateVarKernal(y) if (self.dataPointer.dydx >= 1): for iter in range(0, self.dataPointer.dydx): y = self.takeDerivative(x, y) yAxis = yAxis + '/Cycle' if (self.dataPointer.graphChosen == self.possGraphs[3]): self.plotParallelIntensity(x, xAxis, [y], yAxis, yAxis, [1], plotID) else: #Label and plot Line Graph self.labelKernals(x,y) self.plot2VarLine(x, xAxis, y, yAxis) def type2Variable(self, x, xAxis, y, yAxis, plotID): graphOption = "NULL" if ('globalTotInsn' in self.simplerName) == 'False': graphOption = 1 if (graphOption == 1): if (self.dataPointer.dydx >= 1): for iter in range(0, self.dataPointer.dydx): y = self.takeDerivativeMult(x,y) yAxis = yAxis + '/Cycle' if (self.dataPointer.graphChosen == self.possGraphs[3]): yTicks = [n for n in range(len(y))] self.plotParallelIntensity(x, xAxis, y, yAxis, yAxis, yTicks, plotID) else: self.plotMultVarLine(x, xAxis, y, yAxis) else: x = self.updateVarKernal(x) if (self.dataPointer.dydx >= 1): for iter in range(0, self.dataPointer.dydx): y = self.takeDerivativeMult(x,y) yAxis = yAxis + '/Cycle' if (self.dataPointer.graphChosen == self.possGraphs[3]): yTicks = [n for n in range(len(y))] self.plotParallelIntensity(x, xAxis, y, yAxis, yAxis, yTicks, plotID) else: #Label and Plot self.labelKernalsMult(x, y) self.plotMultVarLine(x,xAxis, y,yAxis) def type3Variable(self, x, xAxis, y, yAxis, plotID): #Type 3 variables are currently those that are used for STACKED BAR PLOTS #if there are kernals.. we need to adjust the x axis for proper labelling #Need to make changes here.. works for now though if 'globalTotInsn' in self.simplerName: x = self.updateVarKernal(x) concentrationFactor = len(x) // 512 + 1 #Scalar Vars numCols = len(y[0]) #the number of columns in the stacked bar plot width = 1.0 #Our bars will occupy 100% of the space allocated to them numRows = len(y) #The number of stacks colours = mpl.cm.get_cmap('RdBu', numRows) #discretizing a matplotlib color scheme to serve as the various colors of our stacked bar plot #Labelling the xAxis with the name of the variable and also the file that the data was chosen from self.plot.set_xlabel(xAxis) #Non-Scalar Vars ind = [tmp for tmp in range(0,numCols)] #the location of the bar and the x axis labels yoff = numpy.array([0.0] * numCols) #variable use to remember the last top location of a bar so that we may stack the proceeding bar on top of it #Legendname = ['UNUSED', 'UNUSED', 'FQPUSHED','ICNT_PUSHED','ICNT_INJECTED','ICNT_AT_DEST','DRAMQ','DRAM_PROCESSING_START','DRAM_PROCESSING_END','DRAM_OUTQ','2SH_ICNT_PUSHED','2SH_ICNT_INJECTED','2SH_ICNT_AT_DEST','2SH_FQ_POP','RETURN_Q']; Legendname = ['N/A', 'N/A','N/A','IcntInpBuf','N/A','Icnt2DRAM','N/A','N/A','N/A','DRAM','2Sh_IcntInpBuf','N/A','Icnt2shd','N/A','N/A']; BarSequence = list(range(numRows-1,-1,-1)) if yAxis == 'WarpDivergenceBreakdown': Legendname = [] Legendname.append('Idle') Legendname.append('Data Hazard') Legendname.append('Stall') for c in range(2, numRows): Legendname.append('W' + repr(4*(c-2)+1) + ':' + repr(4*(c-1))) BarSequence = list(range(0,numRows)) if yAxis == 'WarpIssueSlotBreakdown': Legendname = [] for c in range(0, numRows): Legendname.append('W' + repr(c)) BarSequence = list(range(0,numRows)) dynamic_warp_resolution = 32 if yAxis == 'WarpIssueDynamicIdBreakdown': Legendname = [] for c in range(0, numRows): Legendname.append('W' + repr(dynamic_warp_resolution*c) + ":" + repr(dynamic_warp_resolution*(c+1))) BarSequence = list(range(0,numRows)) yoff_max = numpy.array([0.0] * numCols) for row in range(numRows-1,-1,-1): yoff_max += y[row] for row in BarSequence: row1 = float(row) #Used to select a new color from the colormap.. need to be a float thats why a new variable was made yoff = yoff + y[row] #updating the yoff variable self.plot.bar(ind, y[row], width, bottom = yoff_max-yoff, color=colours(row1/numRows), edgecolor=colours(row1/numRows), label = Legendname[row]) #plotting each set of bar plots individually plotFormat = self.plotFormatInfo[plotID] plotFormat.InitLabels(xlabel = xAxis, ylabel = yAxis, cbarlabel = '', title = yAxis + ' vs ' + xAxis + ' ...' + self.dataPointer.fileChosen[-80:]) self.plot.set_title(plotFormat.title) # More Labelling self.plot.set_xlabel(plotFormat.xlabel, fontsize = plotFormat.labelFontSize) self.plot.set_ylabel(plotFormat.ylabel, fontsize = plotFormat.labelFontSize) matplotlib.rcParams['legend.fontsize'] = plotFormat.yticksFontSize self.plot.legend(loc=(1.01,0.1)) labelValues = [] labelPos = [] try: for count in range(0,len(x)/concentrationFactor,len(x)/8/concentrationFactor): labelValues.append(x[count * concentrationFactor]) labelPos.append(ind[count]) except: pass xlim = self.type3findxlim(ind[-1], x[1]) self.plot.set_xlim(0,xlim / concentrationFactor) self.plot.set_xticklabels(labelValues, rotation = plotFormat.rotation, fontsize = plotFormat.xticksFontSize) self.plot.set_xticks(labelPos) for label in self.plot.get_yticklabels(): label.set_fontsize(plotFormat.yticksFontSize) self.canvas.draw() def type4Variable(self, x, xAxis, y, yAxis, plotID): keys = list(y.keys()) keys.sort() if (self.dataPointer.graphChosen == self.possGraphs[3]): image = [] for iter in keys: image.append(y[iter]) if self.dataPointer.dydx >= 1: for iter in range(0, self.dataPointer.dydx): image = self.takeDerivativeMult(x, image) elif (self.dataPointer.graphChosen == self.possGraphs[5]): # collect a set of majorkeys (assuming format m.n in key) majorKeys = set() dataLength = 0 for k in keys: majork, minork = k.split('.') majorKeys.add(majork) dataLength = len(y[k]) majorKeys = list(majorKeys) majorKeys.sort() # define a (dataLength x #MajorKeys) array image = [[0 for t in range(dataLength)] for s in range(len(majorKeys))] for k in keys: majork, minork = k.split('.') imageArray = image[int(majork)] dataArray = y[k] for pt in range(dataLength): imageArray[pt] += dataArray[pt] if self.dataPointer.dydx >= 1: for iter in range(0, self.dataPointer.dydx): image = self.takeDerivativeMult(x, image) keys = majorKeys else: pass self.plotParallelIntensity(x, xAxis, image, yAxis, yAxis, keys, plotID) def type5Variable(self, x, xAxis, y, yAxis, plotID): assert (self.dataPointer.graphChosen == self.possGraphs[6]) xScatter = y[2][0:] * (x[1] - x[0]) self.plotScatter(xScatter, xAxis, y[1], yAxis, plotID) del xScatter def updateVarKernal(self,var): var = [val for val in var] if self.disconnect == 0: for cycleNum in range(0,len(self.simplerName[self.dataPointer.dataChosenX].data)): if (self.xIsKernal(cycleNum,self.kernalLocs)): for cycleSum in range(self.kernalLocs[self.kernalLocs.index(cycleNum) + 1] - 1, cycleNum - 1, -1): if cycleNum == 0: continue var[cycleSum] += var[cycleNum - 1] return var else: return var def xIsKernal(self,x,kernalStarts): bool = 0 for y in kernalStarts: if (y == x): bool = 1 return bool def findKernalLocs(self): self.kernalLocs = [] prevCycle = -1 countIter = 0 for cycle in self.simplerName[self.dataPointer.dataChosenX].data: if (prevCycle >= cycle): self.kernalLocs.append(countIter) prevCycle = cycle countIter += 1 self.kernalLocs.append(len(self.simplerName[self.dataPointer.dataChosenX].data)) def labelKernalsMult(self,x, y): countKernal = 0 label = "" sum = [] maximum = 0 sumAve = [] for values in range(0,len(y[0])): sum.append(0) for chip in range(0,len(y)): sum[values] += y[chip][values] sumAve.append(sum[values]/len(y)) for vectors in range(0,len(y)): if max(y[vectors]) > max(y[maximum]): maximum = vectors for a in self.kernalLocs: a = a - 1 countKernal += 1 label = " EndKern" + str(countKernal) self.plot.text(x[a],sum[a]/len(y), label, fontsize = 10) tmpx = [x[a], x[a]] tmpy = [0, max(y[maximum])] self.plot.plot(tmpx, tmpy, 'k:' ) def labelKernals(self,x, y): countKernal = 0 label = "" for cycleNum in range(0,len(x)): if(self.xIsKernal(cycleNum,self.kernalLocs)): countKernal += 1 label = " EndKern" + str(countKernal) kernelBound = self.kernalLocs[self.kernalLocs.index(cycleNum)] - 1 self.plot.text(x[kernelBound], y[kernelBound], label, fontsize = 10) kernelBoundx = x[kernelBound] tmpx = [kernelBoundx, kernelBoundx] tmpy = [0, max(y)] self.plot.plot(tmpx, tmpy, 'k:' ) countKernal += 1 label = " EndKern" + str(countKernal) self.plot.text(x[-1], y[-1], label, fontsize = 10) kernelBoundx = x[-1] tmpx = [kernelBoundx, kernelBoundx] tmpy = [0, max(y)] self.plot.plot(tmpx, tmpy, 'k:' ) def plot2VarLine(self, x, xAxis, y, yAxis): self.plot.plot(x, y) self.plot.set_xlim(0, self.xlim) self.plotFormatInfo[self.currPlot].InitLabels(xlabel = xAxis, ylabel = yAxis, cbarlabel = '', title = xAxis + ' vs ' + yAxis + ' ...' + self.dataPointer.fileChosen[-80:]) self.plot.set_title(self.plotFormatInfo[self.currPlot].title) self.plot.set_xlabel(self.plotFormatInfo[self.currPlot].xlabel, fontsize = self.plotFormatInfo[self.currPlot].labelFontSize) self.plot.set_ylabel(self.plotFormatInfo[self.currPlot].ylabel, fontsize = self.plotFormatInfo[self.currPlot].labelFontSize) self.canvas.draw() def plotMultVarLine(self, x, xAxis, y, yAxis): for num in range(0,len(y)): self.plot.plot(x, y[num]) self.plot.set_xlim(0, self.xlim) self.plotFormatInfo[self.currPlot].InitLabels(xlabel = xAxis, ylabel = yAxis, cbarlabel = '', title = '') self.plot.set_xlabel(self.plotFormatInfo[self.currPlot].xlabel, fontsize = self.plotFormatInfo[self.currPlot].labelFontSize) self.plot.set_ylabel(self.plotFormatInfo[self.currPlot].ylabel, fontsize = self.plotFormatInfo[self.currPlot].labelFontSize) self.canvas.draw() def plotScatter(self, x, xAxis, y, yAxis, plotID): plotFormat = self.plotFormatInfo[self.currPlot] self.plot.scatter(x, y, s=5, marker='s', edgecolors='none') self.plot.set_xlim(0, self.xlim) ymax = max(y) ymin = min(y) self.plot.set_ylim(ymin, ymax) plotFormat.InitLabels(xlabel = xAxis, ylabel = yAxis, cbarlabel = '', title = xAxis + ' vs ' + yAxis + ' ...' + self.dataPointer.fileChosen[-80:]) self.plot.set_title(plotFormat.title, fontsize = plotFormat.labelFontSize) self.plot.set_xlabel(plotFormat.xlabel, fontsize = plotFormat.labelFontSize) self.plot.set_ylabel(plotFormat.ylabel, fontsize = plotFormat.labelFontSize) self.canvas.draw() def takeDerivativeMult(self,x,y): multDerivative = [] cycleStep = self.simplerName[self.dataPointer.dataChosenX].data[1] - self.simplerName[self.dataPointer.dataChosenX].data[0] for num in range(0,len(y)): multDerivative.append(self.takeDerivative(x,y[num])) return multDerivative def takeDerivative(self,x,y,b_acc=1): #both variables have to already be organized for this to work!!! #x = [val for val in x] #y = [val for val in y] derivative = array.array('f') prevY = 0 cycleStep = x[1] - x[0] if (cycleStep < 0): prevCycle = 0 for cycle in self.simplerName[self.dataPointer.dataChosenX].data: cycleStep = cycle - prevCycle if cycleStep == 0: continue else: break prevCycle = cycle # fill up self.globalIPC list for yNum in y: if (b_acc == 1 and yNum < prevY): prevY = 0 derivative.append(float(yNum - prevY)/cycleStep) prevY = yNum return derivative def plotParallelIntensity(self, x, xAxis, y, yAxis, colorAxis, yTicks, plotID): # Obtain plot format info plotFormat = self.plotFormatInfo[plotID] # Obtain the matplotlib colormap that we will use for the parallel intensity plot cmap = plotFormat.GetColorMap() #The yAxis/xAxis Labels and their corresponding positions yticks, yticksPos = self.updateWilTicks(y) #currently not using the variable xticks. we want to use values from the x input parameter and place them at 'xticksPos' xticks, xticksPos = self.updateWilTicks(x) #Limits the number of xAxis labels to 8 otherwise the labels will become too cluttered xlabelValues = [] xlabelPos = [] ylabelValues = [] ylabelPos = [] if self.xAxisStepsWilStack[self.currPlot] < 1: self.xAxisStepsWilStack[self.currPlot] = 1 if self.xAxisStepsWilStack[self.currPlot] > len(x): self.xAxisStepsWilStack[self.currPlot] = len(x) if self.yAxisStepsWilStack[self.currPlot] == 'null': self.yAxisStepsWilStack[self.currPlot] = 8 if self.yAxisStepsWilStack[self.currPlot] < 1: self.yAxisStepsWilStack[self.currPlot] = 1 if self.yAxisStepsWilStack[self.currPlot] > len(y): self.yAxisStepsWilStack[self.currPlot] = len(y) # put number on axis if there are more than one ticks if (self.xAxisStepsWilStack[self.currPlot] != 1): for count in range(0,len(x),int(len(x)/self.xAxisStepsWilStack[self.currPlot])): xlabelValues.append(x[count]) xlabelPos.append(xticksPos[count]) print(self.yAxisStepsWilStack[self.currPlot]) for count in range(0,len(y),int(len(y)/self.yAxisStepsWilStack[self.currPlot])): ylabelValues.append(yTicks[count]) ylabelPos.append(yticksPos[count]) #Now that we have all of our axis labels, lets set them self.plot.set_yticklabels(ylabelValues, fontsize = plotFormat.yticksFontSize) self.plot.set_yticks(ylabelPos) self.plot.set_xticklabels(xlabelValues, rotation = plotFormat.rotation, fontsize = plotFormat.xticksFontSize) self.plot.set_xticks(xlabelPos) interpolation = 'nearest' norm = plotFormat.norm im = self.plot.imshow(y, cmap = cmap, interpolation = interpolation, aspect = 'auto', norm = norm ) # tmp = im.get_axes().get_position().get_points() tmp = im.get_window_extent().get_points() if (plotID in self.cbarAxes): self.figure.delaxes(self.cbarAxes[plotID]) cax = self.figure.add_axes([0.91, tmp[0][1], 0.01, tmp[1][1] - tmp[0][1]]) cbar = self.figure.colorbar(im, cax = cax, orientation = 'vertical') self.cbarAxes[plotID]= cax # use for cleanup self.colorbars[self.currPlot] = cbar self.plotFormatInfo[plotID].InitLabels( cbarlabel = 'Scale: ' + colorAxis, xlabel = xAxis + ' ...' + self.dataPointer.fileChosen[-80:], ylabel = yAxis ) cbar.set_label( plotFormat.cbarlabel, fontsize = plotFormat.labelFontSize) for label in cbar.ax.get_yticklabels(): label.set_fontsize(plotFormat.cticksFontSize) self.plot.set_xlabel(plotFormat.xlabel, fontsize = plotFormat.labelFontSize) self.plot.set_ylabel(plotFormat.ylabel, fontsize = plotFormat.labelFontSize) #self.plot.set_title(self.dataChosenY) # provide default scaling to match all plots on figure xtickStep = x[1] - x[0] self.plot.set_xlim(0 / xtickStep - 0.5, self.xlim / xtickStep + 0.5) self.canvas.draw() def updateWilTicks(self, z): x= [] pos = [] for y in range(0,len(z)): x.append(y) pos.append(y) return x, pos def updateWilScaleTicks(self, z): x= [] pos = [] for y in range(0,len(z)): x.append(y) pos.append(y) return x, pos def refreshInputs(self): numPlots = len(self.dataChosen[1]) + 1 self.dataPointer = self.dataChosen[0] for self.currPlot in range(1,numPlots + 1): del self.data[self.dataPointer.fileChosen] self.data[self.dataPointer.fileChosen] = lexyacc.parseMe(self.dataPointer.fileChosen) markForDel = [] for variables in self.data[self.dataPointer.fileChosen]: if self.checkEmpty(self.data[self.dataPointer.fileChosen][variables].data) == 0: markForDel.append(variables) for variables in markForDel: del self.data[self.dataPointer.fileChosen][variables] self.data[self.dataPointer.fileChosen] = organizedata.organizedata(self.data[self.dataPointer.fileChosen]) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] self.graphArea.destroy() self.underneathGraph.destroy() self.currPlot = 1 self.__init__(self.master, self.data, self.res, self.dataChosen) def checkEmpty(self,list): bool = 0 for x in list: if ((x != 0) and (x != 'NULL')): bool = 1 return bool def type3findxlim(self, max, cycleStep): cycleStep = float(cycleStep) factor = 1.0/cycleStep newXlim = self.xlim*factor return newXlim def wilsonScaleX(self, yshort): numPixels = self.xlim/self.cycleStep if len(yshort[0]) < numPixels: length = len(yshort[0]) for rows in range(0,len(yshort)): for count in range(0, numPixels - length): yshort[rows].append(0) return yshort def changeColorMapMaxMin(self): #Variable initializations NEWFRAME = Tk.Toplevel(self.master, bg = 'white') self.currPlot = 1 numPlots = len(self.dataChosen[1]) + 1 absoluteMax = 0 root = [] entry = {} #need to scale all plots to the same length self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() if 'Parallel Intensity Plot' in self.dataPointer.graphChosen: if self.simplerName[self.dataPointer.dataChosenY].type == 5: locMax = self.simplerName[self.dataPointer.dataChosenY].data[0,1][0] locMin = 0 elif self.simplerName[self.dataPointer.dataChosenY].type != 1: if self.dataPointer.dydx == 0: y = self.simplerName[self.dataPointer.dataChosenY].data else: for iter in range(0, self.dataPointer.dydx): if self.simplerName[self.dataPointer.dataChosenY].type == 4: keys = list(self.simplerName[self.dataPointer.dataChosenY].data.keys()) keys.sort() y = [] for iter in keys: y.append(self.simplerName[self.dataPointer.dataChosenY].data[iter]) y = self.takeDerivativeMult(self.simplerName[self.dataPointer.dataChosenX].data, y) else: y = self.takeDerivativeMult(self.simplerName[self.dataPointer.dataChosenX].data, self.simplerName[self.dataPointer.dataChosenY].data) locMax = 0 locMin = 99999999999999999999999999999 for iter in y: if max(iter) > locMax: locMax = max(iter) if locMax > absoluteMax: absoluteMax = locMax for iter in y: if min(iter) < locMin: locMin = min(iter) else: if self.dataPointer.dydx == 0: y = self.simplerName[self.dataPointer.dataChosenY].data else: for iter in range(0, self.dataPointer.dydx): y = self.takeDerivative(self.simplerName[self.dataPointer.dataChosenX].data, self.simplerName[self.dataPointer.dataChosenY].data) locMax = max(y) locMin = min(y) if locMax > absoluteMax: absoluteMax = locMax root.append(Tk.Frame(NEWFRAME, bg = 'white')) root[-1].pack(side = Tk.TOP, anchor = Tk.W, pady = 10) plotLabel = Tk.Label(root[-1], text= '\n' + self.dataPointer.dataChosenY + ' vs ' + self.dataPointer.dataChosenX + '\t Current Max: ' + str(locMax) + ' \t New Max: ', bg= 'white') plotLabel.pack(side = Tk.LEFT) maxEntry = Tk.Entry(root[-1]) maxEntry.insert(0, str(locMax)) maxEntry.pack(side = Tk.LEFT) plotLabel1 = Tk.Label(root[-1], text = '\t Current Min: ' + str(locMin) + '\t New Min: ', bg= 'white') plotLabel1.pack(side = Tk.LEFT) minEntry = Tk.Entry(root[-1]) minEntry.insert(0, str(locMin)) minEntry.pack(side = Tk.LEFT, padx = 15) entry[self.currPlot] = (maxEntry, minEntry) cmap = self.plotFormatInfo[self.currPlot].cmap plotCMap = Tk.OptionMenu(*(root[-1], cmap) + tuple(PlotFormatInfo.cmapOptions)) plotCMap.pack(side = Tk.LEFT, padx = 5) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 15) note = Tk.Label(bottomFrame, text = '*Leave with default values to reset', bg= 'white') note.pack(side = Tk.BOTTOM) bDONE = Tk.Button(bottomFrame, text= 'Submit Changes', bg = 'green', command = lambda: self.collectDataChangeColormaps(entry,NEWFRAME)) bDONE.pack(side = Tk.BOTTOM) bSetToGlobalMax = Tk.Button(bottomFrame, text = 'Normalize all Subplots', command = lambda: self.normalizeSubplots(absoluteMax, entry, NEWFRAME)) bSetToGlobalMax.pack(side = Tk.BOTTOM) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: NEWFRAME.destroy()) bCancel.pack(side = Tk.BOTTOM) def normalizeSubplots(self, absoluteMax, dict, master): listKeys = list(dict.keys()) for plotID in listKeys: self.plotFormatInfo[plotID].norm.vmax = int(absoluteMax) self.plotFormatInfo[plotID].norm.vmin = 0 master.destroy() self.plotData() def collectDataChangeColormaps(self, dict, master): listKeys = list(dict.keys()) for plotID in listKeys: maxEntry, minEntry = dict[plotID] maxValue = maxEntry.get() if maxValue != '': self.plotFormatInfo[plotID].norm.vmax = float(maxValue) minValue = minEntry.get() if minValue != '': self.plotFormatInfo[plotID].norm.vmin = float(minValue) master.destroy() self.plotData() # Now replot with changes..... def takeDerivativeButton(self): #Variable initializations NEWFRAME = Tk.Toplevel(self.master, bg = 'white') self.currPlot = 1 numPlots = len(self.dataChosen[1]) + 1 root = [] checkButton = {} vars = {} #need to scale all plots to the same length self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() if self.dataPointer.graphChosen == 'Parallel Intensity Plot' or self.dataPointer.graphChosen == 'Line': root.append(Tk.Frame(NEWFRAME, bg = 'white')) root[-1].pack(side = Tk.TOP, anchor = Tk.W, pady = 10) plotLabel = Tk.Label(root[-1], text= '\n' + self.dataPointer.dataChosenY + ' vs ' + self.dataPointer.dataChosenX + '\t \t TakeDiv:', bg= 'white') plotLabel.pack(side = Tk.LEFT) vars[str(self.currPlot)] = Tk.IntVar() checkButton[str(self.currPlot)] = Tk.Checkbutton(root[-1], bg = 'white', variable = vars[str(self.currPlot)]) checkButton[str(self.currPlot)].pack(side = Tk.LEFT, padx = 10) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 15) bDONE = Tk.Button(bottomFrame, text= 'Submit Changes', bg = 'green', command = lambda: self.collectDataChangeDiv(vars,NEWFRAME)) bDONE.pack(side = Tk.BOTTOM) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: NEWFRAME.destroy()) bCancel.pack(side = Tk.BOTTOM) def collectDataChangeDiv(self, vars,master): self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] numPlots = len(self.dataChosen[1]) + 1 for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() if str(self.currPlot) in vars: if vars[str(self.currPlot)].get() == 1: self.dataPointer.dydx += 1 if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] master.destroy() ## Now replot with changes..... self.plotData() def changeBinning(self): #Variable initializations NEWFRAME = Tk.Toplevel(self.master, bg = 'white') self.currPlot = 1 numPlots = len(self.dataChosen[1]) + 1 root = Tk.Frame(NEWFRAME, bg = 'white') root.pack(side = Tk.TOP, anchor = Tk.W, pady = 10) plotListbox = Tk.Listbox(root, width = 100, height = 6) plotListbox.grid(row = 0, column = 0, rowspan = 2) bIncreaseBinningX = Tk.Button(root, text = 'Increase Binning X-Axis', command = lambda: self.collectDataIncreaseXBinning(plotListbox.get('active'))) bIncreaseBinningX.grid(row = 0, column = 1, padx = 10) bDecreaseBinningX = Tk.Button(root, text = 'Decrease Binning X-Axis', command = lambda: self.collectDataDecreaseXBinning(plotListbox.get('active'))) bDecreaseBinningX.grid(row = 0, column = 2, padx = 10) bDecreaseBinningX = Tk.Button(root, text = 'Remove Binning X-Axis', command = lambda: self.collectDataDecreaseXBinning(plotListbox.get('active'), remove = True)) bDecreaseBinningX.grid(row = 0, column = 3, padx = 10) bIncreaseBinningY = Tk.Button(root, text = 'Increase Binning Y-Axis', command = lambda: self.collectDataIncreaseYBinning(plotListbox.get('active'))) bIncreaseBinningY.grid(row = 1, column = 1, padx = 10) bDecreaseBinningY = Tk.Button(root, text = 'Decrease Binning Y-Axis', command = lambda: self.collectDataDecreaseYBinning(plotListbox.get('active'))) bDecreaseBinningY.grid(row = 1, column = 2, padx = 10) bDecreaseBinningY = Tk.Button(root, text = 'Remove Binning Y-Axis', command = lambda: self.collectDataDecreaseYBinning(plotListbox.get('active'), remove = True)) bDecreaseBinningY.grid(row = 1, column = 3, padx = 10) bCancel = Tk.Button(root, text = 'Finished' , command = lambda: NEWFRAME.destroy()) bCancel.grid(row = 0, column = 4, padx = 10) #need to scale all plots to the same length self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() if 'Parallel Intensity Plot' in self.dataPointer.graphChosen: plotListbox.insert(Tk.END,str(self.currPlot) + ' ' + self.dataPointer.dataChosenY + ' vs ' + self.dataPointer.dataChosenX) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] def collectDataIncreaseXBinning(self, currPlot): plotToIncrease = int(currPlot[0]) self.xAxisStepsWilStack[plotToIncrease] = self.xAxisStepsWilStack[plotToIncrease] + 20 self.plotDataForNewBinning(plotToIncrease) def collectDataDecreaseXBinning(self, currPlot, remove = False): plotToDecrease = int(currPlot[0]) if (remove == True): self.xAxisStepsWilStack[plotToDecrease] = 1 else: self.xAxisStepsWilStack[plotToDecrease] = self.xAxisStepsWilStack[plotToDecrease] - 5 self.plotDataForNewBinning(plotToDecrease) def collectDataIncreaseYBinning(self, currPlot): plotToIncrease = int(currPlot[0]) if (self.yAxisStepsWilStack[plotToIncrease] == 1): self.yAxisStepsWilStack[plotToIncrease] = 2 self.yAxisStepsWilStack[plotToIncrease] = int(float(self.yAxisStepsWilStack[plotToIncrease])*1.50) print(self.yAxisStepsWilStack[plotToIncrease]) self.plotDataForNewBinning(plotToIncrease) def collectDataDecreaseYBinning(self, currPlot, remove = False): plotToDecrease = int(currPlot[0]) print(self.yAxisStepsWilStack[plotToDecrease]) if (remove == True): self.yAxisStepsWilStack[plotToDecrease] = 1 else: self.yAxisStepsWilStack[plotToDecrease] = int(float(self.yAxisStepsWilStack[plotToDecrease])/1.50) self.plotDataForNewBinning(plotToDecrease) def plotDataForNewBinning(self, plotToChange): self.currPlot = 1 numPlots = len(self.dataChosen[1]) + 1 self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] for self.currPlot in range(1,numPlots + 1): if self.currPlot == plotToChange: self.findKernalLocs() self.plot = self.figure.add_subplot(numPlots,1,self.currPlot) if self.simplerName[self.dataPointer.dataChosenY].type == 1: self.type1Variable(self.simplerName[self.dataPointer.dataChosenX].data , self.dataPointer.dataChosenX, self.simplerName[self.dataPointer.dataChosenY].data, self.dataPointer.dataChosenY, self.simplerName[self.dataPointer.dataChosenY].bool, self.currPlot) elif self.simplerName[self.dataPointer.dataChosenY].type == 2: self.type2Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX, self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) elif self.simplerName[self.dataPointer.dataChosenY].type == 3: self.type3Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX,self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) else: self.type4Variable(self.simplerName[self.dataPointer.dataChosenX].data,self.dataPointer.dataChosenX,self.simplerName[self.dataPointer.dataChosenY].data,self.dataPointer.dataChosenY, self.currPlot) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] def editLabelsButton(self): #Variable initializations NEWFRAME = Tk.Toplevel(self.master, bg = 'white') self.currPlot = 1 numPlots = len(self.dataChosen[1]) + 1 root = Tk.Frame(NEWFRAME, bg = 'white') root.pack(side = Tk.TOP, anchor = Tk.W, pady = 10) entries = {} #need to scale all plots to the same length self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] numPlots = len(self.dataChosen[1]) + 1 currentRow = 0 for self.currPlot in range(1,numPlots + 1): self.plot = self.figure.add_subplot(numPlots,1,self.currPlot) plotFormat = self.plotFormatInfo[self.currPlot] self.findKernalLocs() entries[self.currPlot] = [] plotLabel = Tk.Label(root, text= self.dataPointer.dataChosenY + ' vs ' + self.dataPointer.dataChosenX, bg= 'white') plotLabel.grid(row = currentRow, column = 0, pady = 10, padx = 15, sticky=Tk.W) plotLabel1 = Tk.Label(root, text = 'Y Axis: ', bg = 'white') plotLabel1.grid(row = currentRow, column = 1) entries[self.currPlot].append(Tk.Entry(root)) entries[self.currPlot][-1].grid(row = currentRow, column = 2, padx = 10) entries[self.currPlot][-1].insert(0, self.plot.get_ylabel()) plotLabel2 = Tk.Label(root, text = 'X Axis: ', bg = 'white') plotLabel2.grid(row = currentRow, column = 3) entries[self.currPlot].append(Tk.Entry(root, width = 50)) entries[self.currPlot][-1].grid(row = currentRow, column = 4, padx = 10) entries[self.currPlot][-1].insert(0, self.plot.get_xlabel()) if self.currPlot in self.colorbars: plotLabel3 = Tk.Label(root, text = 'Colorbar: ', bg = 'white') plotLabel3.grid(row = currentRow, column = 5) entries[self.currPlot].append(Tk.Entry(root, width = 20)) entries[self.currPlot][-1].grid(row = currentRow, column = 6, padx = 10) entries[self.currPlot][-1].insert(0, plotFormat.cbarlabel) else: plotLabel3 = Tk.Label(root, text = 'Title: ', bg = 'white') plotLabel3.grid(row = currentRow, column = 5) entries[self.currPlot].append(Tk.Entry(root, width = 20)) entries[self.currPlot][-1].grid(row = currentRow, column = 6, padx = 10) entries[self.currPlot][-1].insert(0, plotFormat.title) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] plotFontLabel = Tk.Label(root, text = 'Label \nFont Size: ', bg = 'white') plotFontLabel.grid(row = currentRow, column = 7) entries[self.currPlot].append(Tk.Entry(root, width = 5)) entries[self.currPlot][-1].grid(row = currentRow, column = 8, padx = 10) entries[self.currPlot][-1].insert(0, plotFormat.labelFontSize) plotFontLabel = Tk.Label(root, text = 'X Ticks \nFont Size: ', bg = 'white') plotFontLabel.grid(row = currentRow, column = 9) entries[self.currPlot].append(Tk.Entry(root, width = 5)) entries[self.currPlot][-1].grid(row = currentRow, column = 10, padx = 10) entries[self.currPlot][-1].insert(0, plotFormat.xticksFontSize) plotFontLabel = Tk.Label(root, text = 'Y Ticks \nFont Size: ', bg = 'white') plotFontLabel.grid(row = currentRow, column = 11) entries[self.currPlot].append(Tk.Entry(root, width = 5)) entries[self.currPlot][-1].grid(row = currentRow, column = 12, padx = 10) entries[self.currPlot][-1].insert(0, plotFormat.yticksFontSize) currentRow += 1 bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 15) bDONE = Tk.Button(bottomFrame, text= 'Submit Changes', bg = 'green', command = lambda: self.collectDataEditLabels(entries,NEWFRAME)) bDONE.pack(side = Tk.BOTTOM) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: NEWFRAME.destroy()) bCancel.pack(side = Tk.BOTTOM) def collectDataEditLabels(self, entries, master): self.dataPointer = self.dataChosen[0] self.simplerName = self.data[self.dataPointer.fileChosen] numPlots = len(self.dataChosen[1]) + 1 for self.currPlot in range(1,numPlots + 1): self.findKernalLocs() self.plot = self.figure.add_subplot(numPlots,1,self.currPlot) plotFormat = self.plotFormatInfo[self.currPlot] labelFontOptionIndex = 3 if entries[self.currPlot][labelFontOptionIndex].get() != '': plotFormat.labelFontSize = int(entries[self.currPlot][labelFontOptionIndex].get()) ticksFontOptionIndex = labelFontOptionIndex + 1 if entries[self.currPlot][ticksFontOptionIndex].get() != '': plotFormat.xticksFontSize = int(entries[self.currPlot][ticksFontOptionIndex].get()) ticksFontOptionIndex = ticksFontOptionIndex + 1 if entries[self.currPlot][ticksFontOptionIndex].get() != '': plotFormat.yticksFontSize = int(entries[self.currPlot][ticksFontOptionIndex].get()) plotFormat.cticksFontSize = plotFormat.yticksFontSize plotFormat.ylabel = entries[self.currPlot][0].get() self.plot.set_ylabel(plotFormat.ylabel, fontsize=plotFormat.labelFontSize) plotFormat.xlabel = entries[self.currPlot][1].get() self.plot.set_xlabel(plotFormat.xlabel, fontsize=plotFormat.labelFontSize) if self.currPlot in self.colorbars: plotFormat.cbarlabel = entries[self.currPlot][2].get() self.colorbars[self.currPlot].set_label(plotFormat.cbarlabel, fontsize=plotFormat.labelFontSize) else: plotFormat.title = entries[self.currPlot][2].get() self.plot.set_title(plotFormat.title) # change xtick label fontsize if (plotFormat.xticksFontSize == 0): self.plot.set_xticklabels([]) xtickslabels = self.plot.get_xmajorticklabels() for n in range(0,len(xtickslabels)): xtickslabels[n].set_fontsize(plotFormat.xticksFontSize) # change ytick label fontsize ytickslabels = self.plot.get_ymajorticklabels() for n in range(0,len(ytickslabels)): ytickslabels[n].set_fontsize(plotFormat.yticksFontSize) # change colorbar ticks label fontsize if self.currPlot in self.colorbars: for label in self.colorbars[self.currPlot].ax.get_yticklabels(): label.set_fontsize(plotFormat.cticksFontSize) if self.dataChosen[1] != [] and self.currPlot != numPlots: self.dataPointer = self.dataChosen[1][self.currPlot - 1] self.simplerName = self.data[self.dataPointer.fileChosen] master.destroy() ## Now replot with changes..... self.canvas.draw() def zoomButton(self): #Variable initializations NEWFRAME = Tk.Toplevel(self.master, bg = 'white') numPlots = len(self.dataChosen[1]) + 1 root = Tk.Frame(NEWFRAME, bg = 'white') root.pack(side = Tk.TOP, anchor = Tk.W, pady = 10) numPlots = len(self.dataChosen[1]) + 1 currentRow = 0 # create text label for fields labelYmin = Tk.Label(root, text = 'Y min: ', bg = 'white') labelYmin.grid(row = currentRow, column = 1) labelYmax = Tk.Label(root, text = 'Y max: ', bg = 'white') labelYmax.grid(row = currentRow, column = 2) labelXmin = Tk.Label(root, text = 'X min: ', bg = 'white') labelXmin.grid(row = currentRow, column = 3) labelXmax = Tk.Label(root, text = 'X max: ', bg = 'white') labelXmax.grid(row = currentRow, column = 4) currentRow += 1 # for x-axis scaling xData = self.simplerName[self.dataPointer.dataChosenX].data xtickStep = xData[1] - xData[0] # create entry fields for each plot entries = {} for plotID in range(1,numPlots + 1): plot = self.plotRef[plotID] plotFormat = self.plotFormatInfo[plotID] ymin, ymax = plot.get_ylim() xmin, xmax = plot.get_xlim() if ('Parallel Intensity Plot' in plotFormat.graphType): ymin = (ymin - 0.5) ymax = (ymax + 0.5) xmin = (xmin + 0.5) * xtickStep xmax = (xmax - 0.5) * xtickStep elif ('Bar Chart' in plotFormat.graphType): xmin = (xmin) * xtickStep xmax = (xmax) * xtickStep plotLabel = Tk.Label(root, text= self.dataPointer.dataChosenY + ' vs ' + self.dataPointer.dataChosenX, bg= 'white') plotLabel.grid(row = currentRow, column = 0, pady = 10, padx = 15, sticky=Tk.W) entries[plotID] = [] # Y min entries[plotID].append(Tk.Entry(root, width = 12)) entries[plotID][-1].grid(row = currentRow, column = 1, padx = 10) entries[plotID][-1].insert(0, ymin) # Y max entries[plotID].append(Tk.Entry(root, width = 12)) entries[plotID][-1].grid(row = currentRow, column = 2, padx = 10) entries[plotID][-1].insert(0, ymax) # X min entries[plotID].append(Tk.Entry(root, width = 12)) entries[plotID][-1].grid(row = currentRow, column = 3, padx = 10) entries[plotID][-1].insert(0, xmin) # X max entries[plotID].append(Tk.Entry(root, width = 12)) entries[plotID][-1].grid(row = currentRow, column = 4, padx = 10) entries[plotID][-1].insert(0, xmax) currentRow += 1 bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 15) bDONE = Tk.Button(bottomFrame, text = 'Apply Changes', bg = 'green', command = lambda: self.zoomCollect(entries,NEWFRAME)) bDONE.pack(side = Tk.BOTTOM) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: NEWFRAME.destroy()) bCancel.pack(side = Tk.BOTTOM) def zoomCollect(self, entries, master): numPlots = len(self.dataChosen[1]) + 1 zoomLimit = [ [] for plotID in range(numPlots + 1) ] # for xtick generation xData = self.simplerName[self.dataPointer.dataChosenX].data xtickStep = xData[1] - xData[0] xLength = len(xData) # obtain entered x and y limit for plotID in range(1,numPlots + 1): plot = self.plotRef[plotID] ylim = plot.get_ylim() xlim = plot.get_xlim() zoomLimit[plotID] = [ylim[0], ylim[1], xlim[0], xlim[1]] for idx in range(len(zoomLimit[plotID])): limitStr = entries[plotID][idx].get() if limitStr != '': zoomLimit[plotID][idx] = float(limitStr) # apply change of x and y limit to each plot for plotID in range(1,numPlots + 1): plot = self.plotRef[plotID] plotFormat = self.plotFormatInfo[plotID] if ('Parallel Intensity Plot' in plotFormat.graphType): zoomLimit[plotID][2] /= xtickStep zoomLimit[plotID][3] /= xtickStep zoomLimit[plotID][0] += 0.5 zoomLimit[plotID][1] -= 0.5 zoomLimit[plotID][2] -= 0.5 zoomLimit[plotID][3] += 0.5 elif ('Bar Chart' in plotFormat.graphType): zoomLimit[plotID][2] /= xtickStep zoomLimit[plotID][3] /= xtickStep plot.set_ylim( ymin = zoomLimit[plotID][0], ymax = zoomLimit[plotID][1]) plot.set_xlim( xmin = zoomLimit[plotID][2], xmax = zoomLimit[plotID][3]) # regenerate the xtick labels if the new maximum is exceeds the data length if ('Parallel Intensity Plot' in plotFormat.graphType or 'Bar Chart' in plotFormat.graphType): xmaxNew = zoomLimit[plotID][3] if (xmaxNew > xLength): xlabelValues = [] xlabelPos = [] if (self.xAxisStepsWilStack[plotID] != 1): xNticks = self.xAxisStepsWilStack[plotID] for count in range(0, int(xmaxNew + 1), int(xmaxNew + 1) / xNticks): xlabelValues.append(count * xtickStep) xlabelPos.append(count) plot.set_xticklabels(xlabelValues, rotation = plotFormat.rotation, fontsize = plotFormat.xticksFontSize) plot.set_xticks(xlabelPos) master.destroy() self.canvas.draw() class NaviPlotInfo: srcViewSection = 'SourceCodeView' def __init__(self): self.titleFontSize = avconfig.get_value(self.__class__.srcViewSection, 'titleFontSize', 12) self.ylabelFontSize = avconfig.get_value(self.__class__.srcViewSection, 'yLabelFontSize', 12) self.xlabelFontSize = avconfig.get_value(self.__class__.srcViewSection, 'xLabelFontSize', 12) self.yticksFontSize = avconfig.get_value(self.__class__.srcViewSection, 'yTicksFontSize', 10) self.xticksFontSize = avconfig.get_value(self.__class__.srcViewSection, 'xTicksFontSize', 10) class newTextTab: srcViewSection = 'SourceCodeView' def __init__(self, textTabs, numb, res, TEFILES): tabnum = "self.page " + numb self.page = textTabs.add(tabnum) self.res = res self.TEFILES = TEFILES self.fileChosen = '' self.typeFileChosen = '' self.chosenStat1 = '' self.chosenStat2 = '' self.key2bool = 0 self.chosenMethod = '' self.showLineStatName = 0 self.first_draw = 1 self.textFont = ('courier', avconfig.get_value(self.__class__.srcViewSection, 'codeFontSize', 8)) self.naviPlotInfo = NaviPlotInfo() if self.res == "small": self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 700, width = 1200); #annotationFrame = Tk.Frame(self.background, bg= 'white', height = 550, width = 400) #textFrame = Tk.Frame(self.background, bg= 'white', height = 550, width = 300) elif self.res == 'medium': self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); #annotationFrame = Tk.Frame(self.background, bg = 'white', height = 700, width = 500) #textFrame = Tk.Frame(self.background, bg= 'white', height = 700, width = 800) else: self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); #annotationFrame = Tk.Frame(self.background, bg= 'green', height = 864, width = 400) #textFrame = Tk.Frame(self.background, bg= 'brown', height = 864, width = 900) self.background.pack() self.background.pack_propagate(0) #annotationFrame.pack(side = Tk.LEFT) #annotationFrame.pack_propagate(0) #textFrame.pack(side = Tk.RIGHT) #textFrame.pack_propagate(0) chooseFileFrame = Tk.Frame(self.background, bg = 'white') chooseFileFrame.pack(side = Tk.TOP, anchor = Tk.W, pady = 10, padx = 5) lChooseFile = Tk.Label(chooseFileFrame, text = 'Choose a Text File to Display: ', font = ("Gills Sans MT", 12), bg = 'white' ) lChooseFile.pack(side= Tk.LEFT) fileListboxOuterFrame = Tk.Frame(chooseFileFrame, bg = 'white') fileListboxOuterFrame.pack(side = Tk.LEFT) cAvailableCudaFilesFrame = Tk.Frame(fileListboxOuterFrame, bg = 'white') cAvailableCudaFilesFrame.pack(side = Tk.TOP) cAvailableCudaFilesTitle = Tk.Label(cAvailableCudaFilesFrame, text= 'Cuda C', bg= 'white') cAvailableCudaFilesTitle.pack(side = Tk.TOP) self.cAvailableCudaFiles = Tk.Listbox(cAvailableCudaFilesFrame, width = 100, height = 4) self.cAvailableCudaFiles.pack(side = Tk.BOTTOM) for keys in TEFILES[0]: self.cAvailableCudaFiles.insert(Tk.END, keys) self.cAvailableCudaFiles.bind("", self.chooseFileCuda) lOr = Tk.Label(chooseFileFrame, text = 'OR', font = ("Gills Sans MT", 20), bg= 'white') lOr.pack(side = Tk.LEFT) cAvailablePTXFilesFrame = Tk.Frame(fileListboxOuterFrame, bg = 'white') cAvailablePTXFilesFrame.pack(side = Tk.BOTTOM) cAvailablePTXFilesTitle = Tk.Label(cAvailablePTXFilesFrame, text= 'PTX', bg= 'white') cAvailablePTXFilesTitle.pack(side = Tk.TOP) self.cAvailablePTXFiles = Tk.Listbox(cAvailablePTXFilesFrame, width = 100, height = 4) self.cAvailablePTXFiles.pack(side = Tk.BOTTOM) for keys in TEFILES[1]: self.cAvailablePTXFiles.insert(Tk.END, keys) self.cAvailablePTXFiles.bind("", self.chooseFilePTX) chooseStatsFrame = Tk.Frame(self.background, bg = 'white') chooseStatsFrame.pack(side = Tk.TOP, anchor = Tk.W, pady = 5, padx =5) lChooseStats = Tk.Label(chooseStatsFrame, text = "Choose Data to be Shown: ", font = ("Gills Sans MT", 12), bg= 'white') lChooseStats.pack(side = Tk.LEFT) availMethodsListboxFrame = Tk.Frame(chooseStatsFrame, bg = 'white') availMethodsListboxFrame.pack(side = Tk.LEFT) lavailMethodsTitle = Tk.Label(availMethodsListboxFrame, text = 'Available Functions', bg= 'white') lavailMethodsTitle.pack(side = Tk.TOP) self.cAvailableMethodsOnStats = Tk.Listbox(availMethodsListboxFrame, width = 25, height = 10) self.cAvailableMethodsOnStats.pack(side = Tk.BOTTOM, anchor = Tk.W) self.cAvailableMethodsOnStats.bind("", self.chooseMethod) availStatsListboxFrame1 = Tk.Frame(chooseStatsFrame, bg = 'white') availStatsListboxFrame1.pack(side = Tk.LEFT) lavailStatsTitle1 = Tk.Label(availStatsListboxFrame1, text = 'Available Stats', bg= 'white') lavailStatsTitle1.pack(side = Tk.TOP) self.cAvailableStats1 = Tk.Listbox(availStatsListboxFrame1, width = 25, height = 10) self.cAvailableStats1.pack(side = Tk.BOTTOM, anchor = Tk.W, padx = 5) self.cAvailableStats1.bind("", self.chooseStats1) availStatsListboxFrame2 = Tk.Frame(chooseStatsFrame, bg = 'white') availStatsListboxFrame2.pack(side = Tk.LEFT) lavailStatsTitle2 = Tk.Label(availStatsListboxFrame2, text = 'Available Stats', bg= 'white') lavailStatsTitle2.pack(side = Tk.TOP) self.cAvailableStats2 = Tk.Listbox(availStatsListboxFrame2, width = 25, height = 10) self.cAvailableStats2.pack(side = Tk.BOTTOM, anchor = Tk.W, padx = 5) self.cAvailableStats2.bind("", self.chooseStats2) chosenDataFrame = Tk.Frame(chooseStatsFrame, bg = 'white') chosenDataFrame.pack(side = Tk.LEFT, padx = 5) lChosenData = Tk.Label(chosenDataFrame, text = 'Chosen Data', bg = 'white') lChosenData.pack(side = Tk.TOP) self.cChosenData = Tk.Text(chosenDataFrame, width = 45, height = 10) self.cChosenData.pack(side = Tk.TOP) self.cChosenData.tag_config('complete', background = 'green') self.cChosenData.tag_config('incomplete', background= 'red') fShowDataFrame = Tk.Frame(self.background, bg = 'white') fShowDataFrame.pack(side = Tk.BOTTOM) self.bShowData = Tk.Button(fShowDataFrame, text = 'Show Data', bg = 'green',font = ("Gills Sans MT", 14), command = lambda: self.showData(),borderwidth = 5) self.bShowData.pack(side = Tk.RIGHT, pady = 10) self.updateChosen() def statString(self, lineNum, statData): if (self.showLineStatName == 1): statName = self.chosenStat1 if (self.chosenStat2 != ''): statName += '/' + self.chosenStat2 finalString = 'Line#: ' + str(lineNum) + ' ' + statName + ': ' + str(statData) + '\n' else: finalString = 'Line#: ' + str(lineNum) + ' : ' + str(statData) + '\n' return finalString def showData(self): self.background.destroy() if self.res == "small": self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 725, width = 1225); topFrame = Tk.Frame(self.background, bg = 'white', height = 442, width = 1225) textFrame = Tk.Frame(topFrame, bg = 'green', height = 442, width = 860) outStatsFrame = Tk.Frame(topFrame, bg= 'white', height = 442, width = 352) statsFrame = Tk.Frame(outStatsFrame, bg = 'red', height = 413, width = 352) bottomFrame = Tk.Frame(self.background, bg= 'purple', height = 284, width = 1225) toolbarFrame = Tk.Frame(outStatsFrame, bg = 'gray', height = 38, width = 352) elif self.res == 'medium': self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); topFrame = Tk.Frame(self.background, bg = 'white', height = 575, width = 1530) textFrame = Tk.Frame(topFrame, bg = 'green', height = 575, width = 1075) outStatsFrame = Tk.Frame(topFrame, bg= 'white', height = 575, width = 440) statsFrame = Tk.Frame(outStatsFrame, bg = 'red', height = 537, width = 440) bottomFrame = Tk.Frame(self.background, bg= 'purple', height = 370, width = 1530) toolbarFrame = Tk.Frame(outStatsFrame, bg = 'black', height = 38, width = 440) else: self.background = Tk.Frame(self.page, bg = "white", borderwidth = 5, relief = Tk.GROOVE, height = 943, width = 1530); topFrame = Tk.Frame(self.background, bg = 'white', height = 575, width = 1530) textFrame = Tk.Frame(topFrame, bg = 'green', height = 575, width = 1075) outStatsFrame = Tk.Frame(topFrame, bg= 'white', height = 575, width = 440) statsFrame = Tk.Frame(outStatsFrame, bg = 'red', height = 537, width = 440) bottomFrame = Tk.Frame(self.background, bg= 'purple', height = 370, width = 1530) toolbarFrame = Tk.Frame(outStatsFrame, bg = 'gray', height = 38, width = 440) self.background.pack_propagate(0) self.background.pack() topFrame.pack_propagate(0) topFrame.pack(side = Tk.TOP) outStatsFrame.pack_propagate(0) outStatsFrame.pack(side = Tk.LEFT) statsFrame.pack_propagate(0) statsFrame.pack(side = Tk.TOP) toolbarFrame.pack_propagate(0) toolbarFrame.pack(side = Tk.TOP) textFrame.pack_propagate(0) textFrame.pack(side = Tk.LEFT) bottomFrame.pack_propagate(0) bottomFrame.pack(side = Tk.TOP) btoolbox = Tk.Button(toolbarFrame, text = 'Toolbox', command = self.toolboxTopLevel) btoolbox.pack(side = Tk.RIGHT) scrollbar = Tk.Scrollbar(statsFrame, orient = Tk.VERTICAL ) scrollbar.pack(side = Tk.RIGHT, fill = 'y') self.textbox = Tk.Text(textFrame, height = 36, width = 150,yscrollcommand = scrollbar.set, wrap = Tk.NONE) self.textbox.pack(side = Tk.TOP, anchor = Tk.W, padx =10, pady = 5) self.statstextbox = Tk.Text(statsFrame, height = 36, width = 55, yscrollcommand = scrollbar.set, wrap = Tk.NONE) self.statstextbox.pack(padx = 10, pady = 5) self.statstextbox.tag_config('normal', background = 'white', font = self.textFont) self.statstextbox.tag_config('highlight',background = 'lightblue', font = self.textFont) scrollbar.config(command = self.yview) self.textbox.tag_config('highlight', background = 'lightblue', font = self.textFont) self.textbox.tag_config('normal', background = 'white', font = self.textFont) self.file = open(self.fileChosen, 'r') self.Lines = {} if self.typeFileChosen == 'cuda': self.statFile = self.TEFILES[2][self.TEFILES[0].index(self.fileChosen)] else: self.statFile = self.TEFILES[2][self.TEFILES[1].index(self.fileChosen) ] self.stats = lexyacctexteditor.textEditorParseMe(self.statFile) if self.typeFileChosen == 'cuda': self.map = lexyacctexteditor.ptxToCudaMapping(self.TEFILES[1][self.TEFILES[2].index(self.statFile) ] ) for keys in self.map: tmp = [] for ptxLines in self.map[keys]: try: tmp.append(self.stats[ptxLines]) except: noDataArray = [] for nStats in variableclasses.lineStatName: noDataArray.append("Null") tmp.append(noDataArray) self.Lines[keys] = variableclasses.cudaLineNo(self.map[keys], tmp) else: for keys in self.stats: self.Lines[keys] = variableclasses.ptxLineNo(self.stats[keys]) countLines = 1 for lines in self.file.readlines(): lines = lines.decode() self.textbox.insert(Tk.END, str(countLines) + '. ' + lines, ('normal')) countLines += 1 countLines -= 1 self.countLines = countLines figure = Figure(figsize=(22,5), dpi = 70) self.histArea = FigureCanvasTkAgg(figure, master= bottomFrame) self.histArea.get_tk_widget().pack() toolbar = NavigationToolbar2Tk(self.histArea, toolbarFrame) toolbar.update() self.histogram = figure.add_subplot(111) cid = figure.canvas.mpl_connect('button_press_event',self.onclick) self.lineCounts = [0.1] for count in range(1,countLines): if count in self.Lines: if self.typeFileChosen == 'cuda': if self.chosenMethod == 'Ratio': self.lineCounts.append(float(self.Lines[count].takeRatioSums(self.chosenStat1, self.chosenStat2))) elif self.chosenMethod == 'Max': self.lineCounts.append(int(self.Lines[count].takeMax(self.chosenStat1))) else: self.lineCounts.append(int(self.Lines[count].sum(self.chosenStat1))) else: if self.chosenMethod == 'Ratio': self.lineCounts.append(float(self.Lines[count].returnRatio(self.chosenStat1, self.chosenStat2))) else: self.lineCounts.append(int(self.Lines[count].returnStat(self.chosenStat1))) else: if count == countLines - 1: self.lineCounts.append(0.1) else: self.lineCounts.append(0) if (self.first_draw == 1): self.xlabelfreq = countLines/30 self.first_draw = 0 self.countLines = countLines width = 0.4 self.generate_xticklabels() self.histogram.set_xlim(0, countLines) self.data_x_posn = [x for x in range(0, countLines)] rects1 = self.histogram.bar(self.data_x_posn, self.lineCounts, width, color = 'blue', edgecolor = 'blue' ) if self.chosenStat2 == '': self.histogram.set_title(self.chosenStat1) else: self.histogram.set_title(self.chosenStat1 + '/' + self.chosenStat2) self.histArea.show() count = 0 for iter in (self.lineCounts + [0]): if count == 0: pass else: self.statstextbox.insert(Tk.END, self.statString(count, iter), ('normal')) count += 1 def yview(self, *args): self.textbox.yview(*args) self.statstextbox.yview(*args) def onclick(self, event): if event.button == 3: shiftFactor = float(15.25)/float(self.countLines) args = ('moveto', str(float(event.xdata)/float(self.countLines) - shiftFactor)) countLines = 1 self.textbox.delete(0.0, Tk.END) self.file = open(self.fileChosen, 'r') for lines in self.file.readlines(): lines=lines.decode() if (countLines < event.xdata - 1) or (countLines > event.xdata + 1): self.textbox.insert(Tk.END, str(countLines) + '. ' + lines, ('normal')) else: self.textbox.insert(Tk.END, str(countLines) + '. ' + lines, ('highlight')) countLines += 1 self.statstextbox.delete(0.0, Tk.END) countLines = 1 count = 1 for iter in (self.lineCounts[1:] + [0]): if (countLines < event.xdata - 1) or (countLines > event.xdata + 1): self.statstextbox.insert(Tk.END, self.statString(count, iter), ('normal')) else: self.statstextbox.insert(Tk.END, self.statString(count, iter), ('highlight')) countLines += 1 count += 1 self.textbox.yview(*args) self.statstextbox.yview(*args) def chooseFileCuda(self, *event): self.fileChosen = self.cAvailableCudaFiles.get('active') self.typeFileChosen = 'cuda' self.chosenStat1 = '' self.chosenStat2 = '' self.key2bool = 0 self.cAvailableStats1.delete(0, Tk.END) self.cAvailableStats2.delete(0, Tk.END) self.cAvailableMethodsOnStats.delete(0, Tk.END) self.cAvailableMethodsOnStats.insert(Tk.END, 'Sum') self.cAvailableMethodsOnStats.insert(Tk.END, 'Max') self.cAvailableMethodsOnStats.insert(Tk.END, 'Ratio') self.updateChosen() def chooseFilePTX(self, *event): self.fileChosen = self.cAvailablePTXFiles.get('active') self.typeFileChosen = 'ptx' self.chosenMethod = '' self.chosenStat1 = '' self.chosenStat2 = '' self.key2bool = 0 self.cAvailableStats1.delete(0, Tk.END) self.cAvailableStats2.delete(0, Tk.END) self.cAvailableMethodsOnStats.delete(0, Tk.END) self.cAvailableMethodsOnStats.delete(0, Tk.END) self.cAvailableMethodsOnStats.insert(Tk.END, 'Stat') self.cAvailableMethodsOnStats.insert(Tk.END, 'Ratio') self.updateChosen() def chooseStats1(self, *event): self.chosenStat1 = self.cAvailableStats1.get('active') self.updateChosen() def chooseStats2(self, *event): self.chosenStat2 = self.cAvailableStats2.get('active') self.updateChosen() def chooseMethod(self, *event): self.chosenMethod = self.cAvailableMethodsOnStats.get('active') self.key2bool = 0 self.cAvailableStats1.delete(0, Tk.END) self.cAvailableStats2.delete(0, Tk.END) if self.typeFileChosen == 'cuda': statFile = self.TEFILES[2][self.TEFILES[0].index(self.fileChosen)] else: statFile = self.TEFILES[2][self.TEFILES[1].index(self.fileChosen)] variableclasses.loadLineStatName(statFile) for statName in variableclasses.lineStatName: self.cAvailableStats1.insert(Tk.END, statName) if self.chosenMethod == 'Ratio': self.key2bool = 1 try: self.cAvailableStats2.delete(0, Tk.END) except: pass for statName in variableclasses.lineStatName: self.cAvailableStats2.insert(Tk.END, statName) self.updateChosen() def updateChosen(self): self.cChosenData.delete(0.0, Tk.END) if self.fileChosen == '': self.cChosenData.insert(Tk.END, 'File: \n', ('incomplete')) self.cChosenData.insert(Tk.END, 'Type File: \n', ('incomplete')) else: self.cChosenData.insert(Tk.END, 'File: ' + self.fileChosen + '\n', ('complete')) self.cChosenData.insert(Tk.END, 'Type File: ' + self.typeFileChosen + '\n', ('complete')) if self.chosenStat1 == '': self.cChosenData.insert(Tk.END, 'Stat1: \n', ('incomplete')) else: self.cChosenData.insert(Tk.END, 'Stat1: ' + self.chosenStat1 + '\n', ('complete')) if self.key2bool == 1: if self.chosenStat2 == '': self.cChosenData.insert(Tk.END, 'Stat2: \n', ('incomplete')) else: self.cChosenData.insert(Tk.END, 'Stat2: ' + self.chosenStat2 + '\n', ('complete')) if self.chosenMethod == '': self.cChosenData.insert(Tk.END, 'Method: \n', ('incomplete')) else: self.cChosenData.insert(Tk.END, 'Method: ' + self.chosenMethod + '\n', ('complete')) def toolboxTopLevel(self): NEWFRAME = Tk.Toplevel(self.background, bg = 'white') changefontsize = Tk.Button(NEWFRAME, text = 'Edit Font Size', command = lambda: ( self.editPlotFontSizes(NEWFRAME))) changefontsize.pack(side = Tk.LEFT, padx = 5, pady = 5) changeLabels = Tk.Button(NEWFRAME, text = 'Edit Label Names', command = lambda:( self.editPlotLabels(NEWFRAME))) changeLabels.pack(side = Tk.LEFT, padx = 5, pady = 5) changeBinning = Tk.Button(NEWFRAME, text = 'Edit X-Axis Binning', command = lambda: (self.changePlotBinning(NEWFRAME))) changeBinning.pack(side = Tk.LEFT, padx = 5, pady = 5) def editPlotLabels(self, oldframe): oldframe.destroy() NEWFRAME = Tk.Toplevel(self.background, bg = 'white') TopFrame = Tk.Frame(NEWFRAME, bg = 'white') TopFrame.pack(side = Tk.TOP) lTitle = Tk.Label(TopFrame, text = 'Title: ', bg= 'white') lTitle.pack(side = Tk.LEFT, padx = 5, pady = 5) eTitle = Tk.Entry(TopFrame) eTitle.insert(0, self.histogram.get_title()) eTitle.pack(side = Tk.LEFT, padx = 5, pady = 5) lYAxis = Tk.Label(TopFrame, text = 'Y Axis ', bg = 'white') lYAxis.pack(side = Tk.LEFT, padx = 5, pady = 5) eYAxis = Tk.Entry(TopFrame) eYAxis.insert(0, self.histogram.get_ylabel()) eYAxis.pack(side = Tk.LEFT, padx = 5, pady = 5) lXaxis = Tk.Label(TopFrame, text = 'X Axis', bg = 'white') lXaxis.pack(side = Tk.LEFT, padx = 5, pady = 5) eXaxis = Tk.Entry(TopFrame) eXaxis.insert(0, self.histogram.get_xlabel()) eXaxis.pack(side = Tk.LEFT, padx = 5, pady = 5) bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 10) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: (NEWFRAME.destroy())) bCancel.pack(side = Tk.TOP, pady = 5) bSubmit = Tk.Button(bottomFrame, text = 'Submit', bg = 'green', command = lambda: self.editPlotLabelsSubmit(NEWFRAME, {'title': eTitle.get(), 'xlabel': eXaxis.get(), 'ylabel': eYAxis.get()})) bSubmit.pack(side = Tk.TOP, pady = 5) def editPlotLabelsSubmit(self, oldFrame, entries): oldFrame.destroy() self.histogram.set_title(entries['title'], fontsize = self.naviPlotInfo.titleFontSize) self.histogram.set_xlabel(entries['xlabel'], fontsize = self.naviPlotInfo.xlabelFontSize) self.histogram.set_ylabel(entries['ylabel'], fontsize = self.naviPlotInfo.ylabelFontSize) self.histArea.show() def editPlotFontSizes(self, oldFrame): oldFrame.destroy() NEWFRAME = Tk.Toplevel(self.background, bg = 'white') TopFrame = Tk.Frame(NEWFRAME, bg = 'white') TopFrame.pack(side = Tk.TOP) lTitle = Tk.Label(TopFrame, text = 'Title Size: ', bg= 'white') lTitle.pack(side = Tk.LEFT, padx = 5, pady = 5) eTitle = Tk.Entry(TopFrame) eTitle.pack(side = Tk.LEFT, padx = 5, pady = 5) lYAxis = Tk.Label(TopFrame, text = 'Y Axis Size: ', bg = 'white') lYAxis.pack(side = Tk.LEFT, padx = 5, pady = 5) eYAxis = Tk.Entry(TopFrame) eYAxis.pack(side = Tk.LEFT, padx = 5, pady = 5) lXaxis = Tk.Label(TopFrame, text = 'X Axis Size: ', bg = 'white') lXaxis.pack(side = Tk.LEFT, padx = 5, pady = 5) eXaxis = Tk.Entry(TopFrame) eXaxis.pack(side = Tk.LEFT, padx = 5, pady = 5) lYBinning = Tk.Label(TopFrame, text = 'Y Axis Binning Size: ', bg = 'white') lYBinning.pack(side = Tk.LEFT, padx = 5, pady = 5) eYBinning = Tk.Entry(TopFrame) eYBinning.pack(side = Tk.LEFT, padx = 5, pady = 5) lXBinning = Tk.Label(TopFrame, text = 'X Axis Binning Size: ', bg= 'white') lXBinning.pack(side = Tk.LEFT, padx = 5, pady = 5) eXBinning = Tk.Entry(TopFrame) eXBinning.pack(side = Tk.LEFT, padx = 5, pady = 5) bottomFrame = Tk.Frame(NEWFRAME, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 10) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: (NEWFRAME.destroy())) bCancel.pack(side = Tk.TOP, pady = 5) bSubmit = Tk.Button(bottomFrame, text = 'Submit', bg = 'green', command = lambda: self.editPlotFontSizesSubmit(NEWFRAME, {'title': eTitle.get(), 'xlabel': eXaxis.get(), 'ylabel': eYAxis.get(), 'ybinning' : eYBinning.get(), 'xbinning': eXBinning.get()})) bSubmit.pack(side = Tk.TOP, pady = 5) def editPlotFontSizesSubmit(self, oldframe, entries): oldframe.destroy() if entries['title'] != '': self.histogram.set_title(self.histogram.get_title(), fontsize = int(entries['title'])) self.naviPlotInfo.titleFontSize = int(entries['title']) if entries['xlabel'] != '': self.histogram.set_xlabel(self.histogram.get_xlabel(), fontsize = int(entries['xlabel'])) self.naviPlotInfo.xlabelFontSize = int(entries['xlabel']) if entries['ylabel'] != '': self.histogram.set_ylabel(self.histogram.get_ylabel(), fontsize = int(entries['ylabel'])) self.naviPlotInfo.ylabelFontSize = int(entries['ylabel']) if entries['ybinning'] != '': for label in self.histogram.get_yticklabels(): label.set_fontsize(int(entries['ybinning'])) self.naviPlotInfo.yticksFontSize = int(entries['ybinning']) if entries['xbinning'] != '': for label in self.histogram.get_xticklabels(): label.set_fontsize(int(entries['xbinning'])) self.naviPlotInfo.xticksFontSize = int(entries['xbinning']) self.histArea.show() def changePlotBinning(self,oldframe): oldframe.destroy() master = Tk.Toplevel(self.background, bg = 'white') topFrame = Tk.Frame(master, bg = 'white') topFrame.pack(side = Tk.TOP) bIncrease = Tk.Button(topFrame, text = 'Increase Frequency', command = lambda: self.increaseBinning()) bIncrease.pack(side = Tk.LEFT, padx = 5, pady = 10) bDecrease = Tk.Button(topFrame, text = 'Decrease Frequency', command = lambda: self.decreaseBinning()) bDecrease.pack(side = Tk.LEFT, padx = 5) bottomFrame = Tk.Frame(master, bg = 'white') bottomFrame.pack(side = Tk.BOTTOM, pady = 10) bCancel = Tk.Button(bottomFrame, text = 'Cancel', command = lambda: (master.destroy())) bCancel.pack(side = Tk.TOP, pady = 5) bSubmit = Tk.Button(bottomFrame, text = 'Submit', bg = 'green', command = lambda: master.destroy()) bSubmit.pack(side = Tk.TOP, pady = 5) def generate_xticklabels(self, fontsize = -1): ind = [x * self.xlabelfreq for x in range(0, self.countLines / self.xlabelfreq)] self.histogram.set_xticks(ind) labels = [] for x in range(0, self.countLines / self.xlabelfreq): labels.append(x * self.xlabelfreq) if (fontsize >= 0): self.histogram.set_xticklabels(labels, fontsize = fontsize) else: self.histogram.set_xticklabels(labels) def increaseBinning(self): self.xlabelfreq = int(self.xlabelfreq / 1.5) if self.xlabelfreq < 1: self.xlabelfreq = 1 self.generate_xticklabels() self.histArea.show() def decreaseBinning(self): self.xlabelfreq = int(self.xlabelfreq * 1.5) self.generate_xticklabels() self.histArea.show()