def demonstrateSOS(): SOS = SSOS() print "Analysis: Initializing SOS..." SOS.init() time.sleep(5.0) iterations = 0 while iterations < 48: sql_string = "select v.val, v.guid, max(v.time_pack), count(v.time_pack) from tblvals v inner join tbldata d on v.guid = d.guid and d.name like 'Iteration' group by (v.guid);" #print "Sending this query to the SOS daemon: " #print " " + sql_string results, col_names = SOS.query(sql_string, "localhost", os.environ['SOS_CMD_PORT']) values = [] themax = 5.0 for i in range(0, len(results)): values.append(float(results[i][0])) if iterations < int(results[i][3]): iterations = int(results[i][3]) if len(values) > 0: themax = check_balance(SOS, values, iterations) time.sleep(themax) SOS.finalize() print "Analysis: DONE!" print
def queryUniqueNames(): SOS = SSOS() sos_host = "localhost" sos_port = os.environ.get("SOS_CMD_PORT") print "Initializing SOS..." SOS.init() print "DONE initializing SOS..." sql_string = """ SELECT DISTINCT value_name FROM viewCombined ; """ results, col_names = SOS.query(sql_string, sos_host, sos_port) numeric_fields = dict() numeric_fields['name'] = [el[0] for el in results] name_count = len(numeric_fields['name']) print str(numeric_fields['name']) print str(name_count) + " unique names." SOS.finalize() print " ...DONE!" print
def demonstrateSOS(): SOS = SSOS() sos_host = "localhost" sos_port = os.environ.get("SOS_CMD_PORT") print "Initializing SOS..." SOS.init() sql_string = "SELECT * FROM viewCombined;" print "Sending this query to the SOS daemon: " print " " + sql_string results, col_names = SOS.query(sql_string, sos_host, sos_port) print "Results:" print " Output.........: " print str(results) print "" print " Row count......: " + str(len(results)) print " Column count...: " + str(len(col_names)) print " Column names...: " # + str(col_names) #pp.pprint(col_names) pp.pprint(col_names) print "" print "Finalizing..." SOS.finalize() print " ...DONE!" print
def demonstrateSOS(): SOS = SSOS() print "Initializing SOS..." SOS.init() count = 0 count_max = 10 print " Packing " + str(count_max) + " integer values in a loop..." while (count < count_max): count = count + 1 SOS.pack(("loop_val_" + str(count)), SOS.INT, count) #SOS.announce() SOS.publish() sql_pubs = "SELECT * FROM tblPubs;" sql_data = "SELECT * FROM tblData;" pubs, col_names = SOS.query(sql_pubs, "localhost", os.environ.get("SOS_CMD_PORT")) print "-----" print "Pubs: (" + str(len(pubs)) + ")" count = 0 print str(col_names) while count < len(pubs): print str(pubs[count]) count = count + 1 data, col_names = SOS.query(sql_data, "localhost", os.environ.get("SOS_CMD_PORT")) print "-----" print "Data: (" + str(len(data)) + ")" count = 0 print str(col_names) while count < len(data): print str(data[count]) count = count + 1 print "" SOS.finalize() print " ...DONE!" print
def ApolloExample(): SOS = SSOS() SOS.init() sos_host = "localhost" sos_port = os.environ.get("SOS_CMD_PORT") sql_string = """ SELECT policyIndex, COUNT(policyIndex) AS iterCount, AVG(DISTINCT sum_time_inclusive_duration) AS avgTime FROM ( SELECT GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "cali.event.attr.level" THEN tblVals.val END) AS "cali_event_attr_level", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "vector_size" THEN tblVals.val END) AS "vector_size", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "cali.event.end" THEN tblVals.val END) AS "cali_event_end", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "iteration" THEN tblVals.val END) AS "iteration", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "policyIndex" THEN tblVals.val END) AS "policyIndex", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "sum#time.inclusive.duration" THEN tblVals.val END) AS "sum_time_inclusive_duration", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "event.end#loop" THEN tblVals.val END) AS "event_end_loop" FROM tblPubs LEFT OUTER JOIN tblData ON tblPubs.guid = tblData.pub_guid LEFT OUTER JOIN tblVals ON tblData.guid = tblVals.guid GROUP BY tblVals.meta_relation_id ) WHERE event_end_loop LIKE 'RAJA_kernel' GROUP BY policyIndex ; """ results, col_names = SOS.query(sql_string, sos_host, sos_port) # ) WHERE cali_event_end IS NOT NULL; # print "==========" print str(col_names) print "----------" # Print out the results in a pretty column-aligned way: widths = [max(map(len, col)) for col in zip(*results)] for row in results: print " ".join((val.ljust(width) for val, width in zip(row, widths))) print "=========="
def ApolloExample(): SOS = SSOS() SOS.init() sos_host = "localhost" sos_port = os.environ.get("SOS_CMD_PORT") sql_string = """ SELECT GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "featureName" THEN tblVals.val END) AS "featureName", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "featureHint" THEN tblVals.val END) AS "featureHint", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "featureGoal" THEN tblVals.val END) AS "featureGoal", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "featureUnit" THEN tblVals.val END) AS "featureUnit", GROUP_CONCAT(CASE WHEN tblData.NAME LIKE "featureValue" THEN tblVals.val END) AS "featureValue" FROM tblPubs LEFT OUTER JOIN tblData ON tblPubs.guid = tblData.pub_guid LEFT OUTER JOIN tblVals ON tblData.guid = tblVals.guid GROUP BY tblVals.meta_relation_id ; """ print sql_string; results, col_names = SOS.query(sql_string, sos_host, sos_port) # ) WHERE cali_event_end IS NOT NULL; # print "" print "==========" print str(col_names) print "----------" for row in results: print str(row) print "=========="
def queryAndPlot(): SOS = SSOS() print "Initializing SOS..." SOS.init() ##### # # Get the maximum simulation frame. # #sql_string = """ #SELECT #MAX(frame) #FROM viewCombined #WHERE viewCombined.value_name LIKE "lulesh.time" #; #""" #results, col_names = SOS.query(sql_string, # "localhost", # os.environ.get("SOS_CMD_PORT")) #max_cycle = int(results[0][0]) #print "Max cycle: " + str(max_cycle) # ##### ##### # # Get the list of field names for non-string values. # # Removed: AND frame = """ + str(max_cycle) + """ # sql_string = """ SELECT DISTINCT value_name FROM viewCombined WHERE value_type NOT LIKE "SOS_VAL_TYPE_STRING" ; """ results, col_names = SOS.query(sql_string, "localhost", os.environ.get("SOS_CMD_PORT")) print "Field names:" for field_name in results: print " " + str(field_name) attr = dict() attr['value_name'] = [el[0] for el in results] name_count = len(attr['value_name']) print str(name_count) + " unique names." # ##### ##### # # Compose a query with those unique fields as columns in the results. # # Removed: sql_string += " WHERE frame = " + str(max_cycle) + " " # sql_string = """ """ sql_string += """ SELECT """ sql_string += """ comm_rank """ sql_string += """,frame """ for field_name in attr['value_name']: sql_string += """,GROUP_CONCAT( CASE WHEN """ sql_string += ' value_name LIKE "' + field_name + '" ' sql_string += ' THEN value END) AS "' + field_name + '" ' sql_string += """ FROM viewCombined """ sql_string += """ GROUP BY """ sql_string += """ comm_rank """ sql_string += """,frame """ sql_string += """;""" print "Composite SQL statement: " print sql_string print "" print "Running composite query..." results, col_names = SOS.query(sql_string, "localhost", os.environ.get("SOS_CMD_PORT")) print "" # # Print out the results: # print "==========" for col in col_names: print str(col) + " " print "==========" for row in results: for col_index in range(len(row)): print str(col_names[col_index]) + ": " + str(row[col_index]) print "----------" print "==========" # ##### SOS.finalize() print " ...DONE!" print
def queryAndPlot(): SOS = SSOS() print "Initializing SOS..." SOS.init() print "DONE init SOS..." sql_string = """ SELECT MAX(frame) FROM viewCombined WHERE viewCombined.value_name LIKE "lulesh.time" ; """ results, col_names = SOS.query(sql_string, "localhost", os.environ.get("SOS_CMD_PORT")) max_cycle = int(results[0][0]) print "Max cycle: " + str(max_cycle) ##### # # Get the list of field names for non-string values. # sql_string = """ SELECT DISTINCT value_name FROM viewCombined WHERE value_type != 3 AND frame = """ + str(max_cycle) + """ ; """ results, col_names = SOS.query(sql_string, "localhost", os.environ.get("SOS_CMD_PORT")) numeric_fields = dict() numeric_fields['name'] = [el[0] for el in results] name_count = len(numeric_fields['name']) print str(name_count) + " unique names." # ##### filenames = [] for c in range(0, (max_cycle + 1)): print "******* CYCLE " + str(c) + " *********" ##### # # Compose a query with the unique numeric fields as columns: # sql_string = """ """ sql_string += """ SELECT """ sql_string += """ comm_rank """ # sql_string += """,frame """ for field_name in numeric_fields['name']: sql_string += """,GROUP_CONCAT( CASE WHEN """ sql_string += ' value_name LIKE "' + field_name + '" ' sql_string += ' THEN value END) AS "' + field_name + '" ' sql_string += """, GROUP_CONCAT( CASE WHEN """ sql_string += ' value_name LIKE "lulesh.coords" ' sql_string += ' THEN value END) AS "lulesh.coords" ' sql_string += """ FROM viewCombined """ sql_string += " WHERE frame = " + str(c) + " " sql_string += """ GROUP BY """ sql_string += """ comm_rank """ # sql_string += """,frame """ sql_string += """;""" #print "Composite SQL statement: " #print sql_string #print "" #print "Running composite query..." results, col_names = SOS.query(sql_string, "localhost", os.environ.get("SOS_CMD_PORT")) #print "" # # Print out the results: # #print "==========" #for col in col_names: # print str(col) + " " #print "==========" #for row in results: # for col_index in range(len(row)): # print str(col_names[col_index]) + ": " + str(row[col_index]) # print "----------" #print "==========" # ##### ##### # # Build an attribute dictionary of the values. # attr = dict() attr['comm_rank'] = [el[0] for el in results] position = 1 for field_name in numeric_fields['name']: attr[field_name] = [el[position] for el in results] #print str(field_name) + " in position " + str(position) + " = " + str(attr[field_name]) position += 1 res_coords = [el[position] for el in results] #print "lulesh.coords in position " + str(position) + " = " + str(res_coords) for field_name in numeric_fields['name']: rank = 0 for this_ranks_value in attr[field_name]: print "comm_rank(" + str( rank) + ")." + field_name + " = " + this_ranks_value rank += 1 rank_max = len(attr['comm_rank']) coords = list() coords = [el.split() for el in res_coords] #print attr dset = vtk_writer.vtk_hex_data_set() dset.clear() dset.set_cycle(c) for rank in range(rank_max): fields = {} for field_name in numeric_fields['name']: fields[field_name] = attr[field_name][rank] fields["rank"] = rank hex_coords = [None] * 24 xpt = [None] * 8 ypt = [None] * 8 zpt = [None] * 8 cpt = [None] * 8 for i in range(24): hex_coords[i] = float(coords[rank][i]) dset.add_hex(hex_coords, fields, rank) dset.write_vtk_file() filenames.append(dset.get_file_name()) vtk_writer.write_visit_file(filenames) visit.AddArgument("-par") visit.Launch() OpenDatabase("dataset.visit") AddPlot("Pseudocolor", "rank") AddPlot("Mesh", "mesh") DrawPlots() # loop through times tsNames = GetWindowInformation().timeSliders for ts in tsNames: SetActiveTimeSlider(ts) for state in list(range(TimeSliderGetNStates()))[::10] + [0]: SetTimeSliderState(state) print "Setting share_power permissions on the newly created VTK files..." subprocess.call("$PROJECT_BASE/share_power .", shell=True) print "" print "Sleeping for 100 seconds..." print "" time.sleep(100) SOS.finalize() print " ...DONE!" print
def sosAutoTranspose(): SOS = SSOS() sosHost = "localhost" sosPort = os.environ.get("SOS_CMD_PORT") printf("Initializing SOS: ...\b\b\b") SOS.init() printf("OK!\n") ##### # # Get the maximum simulation cycle found in the database. # # NOTE: The cycleFieldName variable should match what is being used # either by your application or SOSflow. If you are not using # an explicit cycle value, you can use SOSflow's internal # field named "frame" that is updated every time SOS_publish(...) # is called. As long as you are publishing to SOS at the end # of major program steps, this will give you what you want. # # NOTE: For online queries, if you want to ensure that your most # current projection represents a complete set of values, # and you're investigating a block-synchronous code, you can # grab the current maximum and subtract one. # cycleFieldName = "frame" # sqlMaxFrame = "SELECT MAX(" + cycleFieldName + ") FROM viewCombined;" results, col_names = SOS.query(sqlMaxFrame, sosHost, sosPort) max_cycle = int(results[0][0]) print "Maximum observed '" + cycleFieldName + "' value: " + str(max_cycle) # sqlMaxFrame = "SELECT MAX(comm_rank) FROM viewCombined;" results, col_names = SOS.query(sqlMaxFrame, sosHost, sosPort) rank_max = int(results[0][0]) print "Maximum observed 'comm_rank' value: " + str(rank_max) # ##### ##### # # Get the list of field names we will use to build a custom query. # # NOTE: To filter out SOS_VAL_TYPE_STRING fields, add in: # ... += "WHERE value_type != 3" sqlFieldNames = """ SELECT DISTINCT value_name FROM viewCombined ; """ results, col_names = SOS.query(sqlFieldNames, sosHost, sosPort) selectedFields = dict() selectedFields['name'] = [el[0] for el in results] name_count = len(selectedFields['name']) printf("(%d fields)", name_count) printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b") # # NOTE: Debug output... # #print "Selected " + str(name_count) + " unique names:" #for name in selectedFields['name']: # print " " + str(name) #print "" # ##### ##### # # Compose a query with the unique numeric fields as columns: sqlValsToColsByRank = """ """ sqlValsToColsByRank += """ SELECT """ sqlValsToColsByRank += """ comm_rank """ for field_name in selectedFields['name']: sqlValsToColsByRank += """,GROUP_CONCAT( CASE WHEN """ sqlValsToColsByRank += ' value_name LIKE "' + field_name + '" ' sqlValsToColsByRank += ' THEN value END) AS "' + field_name + '" ' #end:for field_name # # NOTE: We can now manually grab some hardcoded field names # that might not have been included in selectedFields # if things were being filtered by type: # # sqlValsToColsByRank += """ FROM viewCombined """ # # NOTE: Uncomment this, and comment out the 'GROUP BY' frame below, # for cases where we only want to see the largest frame. # #sqlValsToColsByRank += " WHERE frame = " + str(simCycle) + " " sqlValsToColsByRank += """ GROUP BY """ sqlValsToColsByRank += """ comm_rank """ sqlValsToColsByRank += """,frame """ sqlValsToColsByRank += """;""" # results, col_names = SOS.query(sqlValsToColsByRank, sosHost, sosPort) # # ##### print str(col_names) print str(results) ##### # # Whew! All done! # # NOTE: See vtkWriter.py for more details. # SOS.finalize() # ##### print " ...DONE!" print return
def sosVTKProjector(): SOS = SSOS() sosHost = "localhost" sosPort = os.environ.get("SOS_CMD_PORT") printf("Initializing SOS: ...\b\b\b") SOS.init() printf("OK!\n") ##### # # Get the maximum simulation cycle found in the database. # # NOTE: The cycleFieldName variable should match what is being used # either by your application or SOSflow. If you are not using # an explicit cycle value, you can use SOSflow's internal # field named "frame" that is updated every time SOS_publish(...) # is called. As long as you are publishing to SOS at the end # of major program steps, this will give you what you want. # # NOTE: For online queries, if you want to ensure that your most # current projection represents a complete set of values, # and you're investigating a block-synchronous code, you can # grab the current maximum and subtract one. # cycleFieldName = "frame" # sqlMaxFrame = "SELECT MAX(" + cycleFieldName + ") FROM viewCombined;" results, col_names = SOS.query(sqlMaxFrame, sosHost, sosPort) max_cycle = int(results[0][0]) print "Maximum observed '" + cycleFieldName + "' value: " + str(max_cycle) # sqlMaxFrame = "SELECT MAX(comm_rank) FROM viewCombined;" results, col_names = SOS.query(sqlMaxFrame, sosHost, sosPort) rank_max = int(results[0][0]) print "Maximum observed 'comm_rank' value: " + str(rank_max) # ##### ##### # # Here we drive the generation of the .vtk file[s]: filenames = [] # # NOTE: When allocation time is scarce, 'stride' here can be # set so that intermediate cycles can be skipped, which is # especially useful when there are thousands of cycles. # stride = 1 # # EXAMPLE A: Generate .vtk set for ALL simulation cycles: print "Generating VTK files..." lastX = [0.0] * (rank_max + 1) lastY = [0.0] * (rank_max + 1) lastZ = [0.0] * (rank_max + 1) for simCycle in range(0, max_cycle, stride): printf(" ... %d of %d ", (simCycle + 1), max_cycle) vtkOutputFileName = generateVTKFile(SOS, cycleFieldName, simCycle, lastX, lastY, lastZ) filenames.append(vtkOutputFileName) #end:for simCycle printf(" ") printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b") printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b") # ----- # EXAMPLE B: Generate .vtk file for MOST RECENT cycle: #vtkOutputFile = generateVTKFile(selectedFields, max_cycle) #filenames.append(vtkOutputFile) # ##### ##### # # Produce a dataset.visit 'group file' that tells VisIt obout our per- # cycle .vtk files, to explore them in sequence: vtk_writer.write_visit_file(filenames) # ##### ##### # # NOTE: This block of code can be used to launch VisIt automatically # after the script generates the input file. # #visit.AddArgument("-par") #visit.Launch() #OpenDatabase("dataset.visit") #AddPlot("Pseudocolor", "rank") #AddPlot("Mesh", "mesh") #DrawPlots() # loop through times #tsNames = GetWindowInformation().timeSliders #for ts in tsNames: # SetActiveTimeSlider(ts) #for state in list(range(TimeSliderGetNStates()))[::10] + [0]: # SetTimeSliderState(state) #print "Setting share_power permissions on the newly created VTK files..." #subprocess.call("$PROJECT_BASE/share_power .", shell=True) #print "" #print "Sleeping for 100 seconds..." #print "" #time.sleep(100) # ##### ##### # # Whew! All done! # # NOTE: See vtkWriter.py for more details. # SOS.finalize() # ##### print " ...DONE!" print return