libstdc++-v3/scripts/make_graph.py

   1 #!/usr/bin/python
   2
   3 import string
   4 import sys
   5 import re
   6 import os
   7 import platform
   8 import commands
   9 from Numeric import *
  10 from pychart import *
  11 from xml.dom import minidom
  12
  13 class exception:
  14         pass
  15
  16
  17 def comp_platform_info(compiler):
  18         ret = '<ul>\n'
  19         so = commands.getstatusoutput('cat /proc/cpuinfo | grep \'cpu MHz\'')
  20         if so[0] == 0:
  21                 ret += '<li>CPU speed - %s</li>\n' % so[1]
  22         so = commands.getstatusoutput('cat /proc/meminfo | grep \'MemTotal\'')
  23         if so[0] == 0:
  24                 ret += '<li>Memory - %s</li>\n' % so[1]
  25         ret += '<li>Platform - %s</li>\n' % platform.platform()
  26         so = commands.getstatusoutput(compiler + ' --version')
  27         if so[0] == 0:
  28                 ret += '<li>Compiler - %s</li>\n' % so[1]
  29         ret += '</ul>\n'
  30         return ret
  31
  32
  33 class res:
  34         """
  35         A 'structure' representing the results of a test.
  36         """
  37         def __init__(self, x_label, y_label, cntnr_list, cntnr_descs, res_sets):
  38                 self.x_label = x_label
  39                 self.y_label = y_label
  40                 self.cntnr_list = cntnr_list
  41                 self.cntnr_descs = cntnr_descs
  42                 self.res_sets = res_sets
  43
  44
  45 class res_getter:
  46         """
  47         This class returns a res object for some test.
  48         """
  49         class __sorter:
  50                 def __accum(self, results):
  51                         total = 0
  52                         for result in results:
  53                                 total = total + result[1]
  54                         return total
  55
  56                 def sort(self, cntnr_list, res_sets):
  57                         cntnrs_and_totals = []
  58                         for cntnr in cntnr_list:
  59                                 results = res_sets[cntnr]
  60                                 total = self.__accum(results)
  61                                 cntnrs_and_totals.append((cntnr, total))
  62                         by_total = lambda x,y: x[1] > y[1] and -1 or 1
  63                         cntnrs_and_totals.sort(by_total)
  64                         ret = []
  65                         for cntnr_and_total in cntnrs_and_totals:
  66                                 cntnr = cntnr_and_total[0]
  67                                 ret.append(cntnr)
  68                         return ret
  69
  70         def __init__(self, test_infos_f_name):
  71                 self.__test_to_container_res_sets = {}
  72                 self.__test_to_f_names = {}
  73                 tests_dat = minidom.parse(test_infos_f_name)
  74                 for test in tests_dat.getElementsByTagName('test'):
  75                         test_name = test.attributes['name'].value
  76                         self.__test_to_f_names[test_name] = test.getElementsByTagName('file')[0].attributes['name'].value
  77                         cntnr_list = []
  78                         for cntnr in test.getElementsByTagName('cntnr'):
  79                                 cntnr_list.append(cntnr.attributes['name'].value)
  80                         self.__test_to_container_res_sets[test_name] = cntnr_list
  81
  82         def __get_label(self, tst_dat, label_name):
  83                 label = tst_dat.getElementsByTagName(label_name)[0].firstChild.data
  84                 label = string.strip(label, '\n')
  85                 label = string.strip(label)
  86                 return label
  87
  88         def __parse_res_sets(self, f_name, cntnr_list):
  89                 tst_dat = minidom.parse(f_name)
  90                 x_label = self.__get_label(tst_dat, 'x_name')
  91                 y_label = self.__get_label(tst_dat, 'y_name')
  92                 parsed_container_list = tst_dat.getElementsByTagName('cntnr')
  93                 res_sets = {}
  94                 cntnr_descs = {}
  95                 for cntnr in parsed_container_list:
  96                         cntnr_name = cntnr.attributes["name"].value
  97                         res_sets[cntnr_name] = []
  98                 for cntnr in parsed_container_list:
  99                         cntnr_name = cntnr.attributes["name"].value
 100                         cntnr_desc = cntnr.getElementsByTagName('desc')
 101                         if res_sets.has_key(cntnr_name):
 102                                 res_set = []
 103                                 result_list = cntnr.getElementsByTagName('result')
 104                                 for result in result_list:
 105                                         x = string.atol(result.attributes["x"].value)
 106                                         y = string.atof(result.attributes["y"].value)
 107                                         res_set.append((x, y))
 108                                 res_sets[cntnr_name] = res_set
 109                                 cntnr_descs[cntnr_name] = cntnr_desc[0]
 110                 return (x_label, y_label, cntnr_descs, res_sets)
 111
 112         def get(self, res_dir, test_name):
 113                 cntnr_list = self.__test_to_container_res_sets[test_name]
 114                 f_name = res_dir + '/' + self.__test_to_f_names[test_name]
 115                 parsed = self.__parse_res_sets(f_name, cntnr_list)
 116                 x_label = parsed[0]
 117                 y_label = parsed[1]
 118                 cntnr_descs = parsed[2]
 119                 res_sets = parsed[3]
 120                 cntnr_list = self.__sorter().sort(cntnr_list, res_sets)
 121                 return res(x_label, y_label, cntnr_list, cntnr_descs, res_sets)
 122
 123
 124 class png_maker:
 125         """
 126         This class creates a png file from a result set.
 127         """
 128         class __style_chooser:
 129                 def __init__(self):
 130                         self.native_re = re.compile(r'n_(?:.*?)')
 131
 132                         self.native_tick_mark_0 = tick_mark.Circle(size = 4)
 133                         self.native_tick_mark_1 = tick_mark.Square(size = 4)
 134                         self.native_line_style_0 = line_style.T(color = color.black, width=2)
 135                         self.native_line_style_1 = line_style.T(color = color.black, width=2)
 136
 137                         self.mask_re = re.compile(r'mask(?:.*?)')
 138                         self.mod_re = re.compile(r'mod(?:.*?)')
 139
 140                         self.rb_tree_mmap_rb_tree_set_re = re.compile(r'rb_tree_mmap_rb_tree_set(?:.*?)')
 141                         self.rb_tree_mmap_lu_mtf_set_re = re.compile(r'rb_tree_mmap_lu_mtf_set(?:.*?)')
 142
 143                         self.splay_re = re.compile(r'splay(?:.*?)')
 144                         self.rb_tree_re = re.compile(r'rb_tree(?:.*?)')
 145                         self.ov_tree_re = re.compile(r'ov_tree(?:.*?)')
 146                         self.splay_tree_re = re.compile(r'splay_tree(?:.*?)')
 147
 148                         self.pat_trie_re = re.compile(r'pat_trie(?:.*?)')
 149
 150                         self.lc_1div8_1div2_re = re.compile(r'lc_1div8_1div2(?:.*?)')
 151                         self.lc_1div8_1div1_re = re.compile(r'lc_1div8_1div1(?:.*?)')
 152                         self.mcolc_1div2_re = re.compile(r'mcolc_1div2(?:.*?)')
 153
 154                 def choose(self, cntnr):
 155                         if self.native_re.search(cntnr):
 156                                 if cntnr == 'n_pq_vector':
 157                                         return (self.native_tick_mark_1, self.native_line_style_1)
 158
 159                                 return (self.native_tick_mark_0, self.native_line_style_0)
 160
 161                         # tick_mark predefined
 162                         # square, circle3, dia, tri, dtri, star, plus5, x5, gray70dia, blackdtri, blackdia
 163                         if self.mask_re.search(cntnr):
 164                                 clr = color.navy
 165                         elif self.mod_re.search(cntnr):
 166                                 clr = color.green4
 167                         elif self.rb_tree_mmap_rb_tree_set_re.search(cntnr):
 168                                 clr = color.mediumblue
 169                                 tm = tick_mark.square
 170                         elif self.rb_tree_mmap_lu_mtf_set_re.search(cntnr) or cntnr == 'rc_binomial_heap':
 171                                 clr = color.gray50
 172                                 tm = tick_mark.dia
 173                         elif self.splay_tree_re.search(cntnr) or cntnr == 'binomial_heap':
 174                                 clr = color.gray58
 175                                 tm = tick_mark.tri
 176                         elif self.rb_tree_re.search(cntnr) or cntnr == 'binary_heap':
 177                                 clr = color.red3
 178                                 tm = tick_mark.dtri
 179                         elif self.ov_tree_re.search(cntnr) or cntnr == 'thin_heap':
 180                                 clr = color.orangered1
 181                                 tm = tick_mark.star
 182                         elif self.pat_trie_re.search(cntnr) or cntnr == 'pairing_heap':
 183                                 clr = color.blueviolet
 184                                 tm = tick_mark.plus5
 185                         else:
 186                                 sys.stderr.write(cntnr + '\n')
 187                                 raise exception
 188
 189                         # mask / mod
 190                         if cntnr.find('lc_1div8_1div') <> -1:
 191                                 if cntnr.find('mask') <> -1:
 192                                         # mask
 193                                         if self.lc_1div8_1div2_re.search(cntnr):
 194                                                 if cntnr.find('nsth') <> -1:
 195                                                         tm = tick_mark.x5
 196                                                 else:
 197                                                         tm = tick_mark.gray70dia
 198                                         if self.lc_1div8_1div1_re.search(cntnr):
 199                                                 if cntnr.find('nsth') <> -1:
 200                                                         tm = tick_mark.dia
 201                                                 else:
 202                                                         tm = tick_mark.circle3
 203                                 else:
 204                                         # mod
 205                                         if self.lc_1div8_1div2_re.search(cntnr):
 206                                                 if cntnr.find('nsth') <> -1:
 207                                                         tm = tick_mark.tri
 208                                                 else:
 209                                                         tm = tick_mark.square
 210                                         if self.lc_1div8_1div1_re.search(cntnr):
 211                                                 if cntnr.find('nsth') <> -1:
 212                                                         tm = tick_mark.dtri
 213                                                 else:
 214                                                         tm = tick_mark.star
 215
 216                         if self.mcolc_1div2_re.search(cntnr):
 217                                 tm = tick_mark.circle3
 218
 219                         return (tm, line_style.T(color = clr, width = 2))
 220
 221
 222         def __init__(self):
 223                 self.__sc = self.__style_chooser()
 224                 self.__mmap_re = re.compile('mmap_')
 225
 226         def __container_label_name(self, cntnr):
 227                 return self.__mmap_re.sub('\nmmap_\n', cntnr)
 228
 229         def make(self, res, of_name):
 230                 theme.output_format = 'svg'
 231                 theme.output_file = of_name
 232                 theme.scale_factor = 2
 233                 theme.default_font_family = "Gill Sans Std"
 234                 theme.default_line_width = 0.5
 235                 theme.default_font_size = 7
 236                 theme.use_color = 1
 237                 theme.reinitialize()
 238                 y_tick_interval = self.__get_y_tics(res)
 239 #               xaxis = axis.X(format = '/a90/hL%d',
 240                 xaxis = axis.X(format = "/a-50{}%d",
 241                                tic_interval = 200,
 242                                label = res.x_label)
 243 #               yaxis = axis.Y(format = '%.2e',
 244                 yaxis = axis.Y(format = "/a-50{}%.2e",
 245                                tic_interval = y_tick_interval,
 246                                label = res.y_label)
 247                 legend_lines = len(res.cntnr_list)
 248                 legend_vloc = 50 + (legend_lines * 10)
 249                 legend_hloc = -0
 250                 ar = area.T(x_axis = xaxis, y_axis = yaxis,
 251                             legend = legend.T(loc=(legend_hloc,-legend_vloc),
 252                                               frame_line_style=None,
 253                                               inter_row_sep=2),
 254                             size=(240,110))
 255                 plot_list = []
 256                 for cntnr in res.cntnr_list:
 257                         style = self.__sc.choose(cntnr)
 258                         print cntnr
 259                         pl = line_plot.T(label = self.__container_label_name(cntnr),
 260                                 data = res.res_sets[cntnr],
 261                                 tick_mark = style[0],
 262                                 line_style = style[1])
 263                         plot_list.append(pl)
 264                 for plot in plot_list:
 265                         ar.add_plot(plot)
 266                 ar.draw()
 267
 268
 269         def __get_y_tics(self, res):
 270                 mx = 0
 271                 for cntnr in res.cntnr_list:
 272                         m = max(d[1] for d in res.res_sets[cntnr])
 273                         mx = max(m, mx)
 274                 return mx / 5
 275
 276
 277
 278 def make_tt(s):
 279         return '<tt>' + s + '</tt>'
 280
 281 def make_b(s):
 282         return '<b>' + s + '</b>'
 283
 284 def make_ttb(s):
 285         return '<tt><b>' + s + '</b></tt>'
 286
 287 def make_i(s):
 288         return '<i>' + s + '</i>'
 289
 290 def make_pb_ds_class_href(c_name):
 291         return '<a href = "' + c_name + '.html">' + make_tt(c_name) + '</a>\n'
 292
 293 def build_value_to_pb_ds_class_href(s_desc):
 294         value = s_desc.attributes['value'].value
 295         ret = make_pb_ds_class_href(value)
 296         return ret
 297
 298 class hash_desc_to_html_builder:
 299         def build_specific_comb_hash_fn(self, s_desc):
 300                 comb_hash_fn_desc = s_desc.getElementsByTagName('Comb_Hash_Fn')[0]
 301                 ret = make_tt('Comb_Hash_Fn')
 302                 ret = ret + ' = '
 303                 ret = ret + build_value_to_pb_ds_class_href(comb_hash_fn_desc)
 304                 return ret
 305
 306         def __build_nom_denom(self, s_desc):
 307                 nom_denom = s_desc.attributes['nom'].value + '/' + s_desc.attributes['denom'].value
 308                 return make_i(nom_denom)
 309
 310         def __build_lc_trigger_desc(self, s_desc):
 311                 ret = build_value_to_pb_ds_class_href(s_desc)
 312                 ret = ret + ' with ' + make_i('&alpha;<sub>min</sub>')
 313                 ret = ret + ' = '  + self.__build_nom_denom(s_desc.getElementsByTagName('alpha_min')[0])
 314                 ret = ret + ' and ' + make_i('&alpha;<sub>max</sub>')
 315                 ret = ret + ' = '  + self.__build_nom_denom(s_desc.getElementsByTagName('alpha_max')[0])
 316                 return ret
 317
 318         def build_specific_resize_policy(self, s_desc):
 319                 ret = make_tt('Resize_Policy')
 320                 ret = ret + ' = '
 321                 resize_policy_desc = s_desc.getElementsByTagName('Resize_Policy')[0]
 322                 ret = ret + build_value_to_pb_ds_class_href(resize_policy_desc)
 323                 ret = ret + ' with ' + make_tt('Size_Policy')
 324                 ret = ret + ' = '
 325                 size_policy_desc = resize_policy_desc.getElementsByTagName('Size_Policy')[0]
 326                 ret = ret + build_value_to_pb_ds_class_href(size_policy_desc)
 327                 ret = ret + ', and ' + make_tt('Trigger_Policy')
 328                 ret = ret + ' = '
 329                 trigger_policy_desc = resize_policy_desc.getElementsByTagName('Trigger_Policy')[0]
 330                 if trigger_policy_desc.attributes['value'].value == 'hash_load_check_resize_trigger':
 331                         ret = ret + self.__build_lc_trigger_desc(trigger_policy_desc)
 332                 else:
 333                         raise exception
 334                 return ret
 335
 336
 337 class cc_hash_desc_to_html_builder:
 338         def __init__(self):
 339                 self.__hash_builder = hash_desc_to_html_builder()
 340
 341         def build(self, s_desc):
 342                 ret = build_value_to_pb_ds_class_href(s_desc)
 343                 ret = ret + 'with ' + self.__hash_builder.build_specific_comb_hash_fn(s_desc)
 344                 ret = ret + ', and ' + self.__hash_builder.build_specific_resize_policy(s_desc)
 345                 return ret
 346
 347
 348 class gp_hash_desc_to_html_builder:
 349         def __init__(self):
 350                 self.__hash_builder = hash_desc_to_html_builder()
 351
 352         def build(self, s_desc):
 353                 ret = build_value_to_pb_ds_class_href(s_desc)
 354                 ret = ret + ' with ' + self.__hash_builder.build_specific_comb_hash_fn(s_desc)
 355                 ret = ret + ', ' + self.__hash_builder.build_specific_resize_policy(s_desc)
 356                 ret = ret + ', and ' + make_tt('Probe_Fn')
 357                 ret = ret + ' = '
 358                 probe_fn = s_desc.getElementsByTagName('Probe_Fn')[0].attributes['value'].value
 359                 ret = ret + make_pb_ds_class_href(probe_fn)
 360                 return ret
 361
 362
 363 class basic_tree_like_desc_to_html_builder:
 364         def build_tag(self, s_desc):
 365                 ret = make_tt('Tag')
 366                 ret = ret + ' = '
 367                 tag_desc = s_desc.getElementsByTagName('Tag')[0]
 368                 ret = ret + build_value_to_pb_ds_class_href(tag_desc)
 369                 return ret
 370
 371         def build_node_update(self, s_desc):
 372                 ret = make_tt('Node_Update')
 373                 ret = ret + ' = '
 374                 node_update_desc = s_desc.getElementsByTagName('Node_Update')[0]
 375                 ret = ret + build_value_to_pb_ds_class_href(node_update_desc)
 376                 return ret
 377
 378
 379 class basic_tree_desc_to_html_builder:
 380         def __init__(self):
 381                 self.__tree_like_builder = basic_tree_like_desc_to_html_builder()
 382
 383         def build(self, s_desc):
 384                 ret = build_value_to_pb_ds_class_href(s_desc)
 385                 ret = ret + ' with ' + self.__tree_like_builder.build_tag(s_desc)
 386                 ret = ret + ', and ' + self.__tree_like_builder.build_node_update(s_desc)
 387                 return ret
 388
 389
 390 class basic_trie_desc_to_html_builder:
 391         def __init__(self):
 392                 self.__tree_like_builder = basic_tree_like_desc_to_html_builder()
 393
 394         def build(self, s_desc):
 395                 ret = build_value_to_pb_ds_class_href(s_desc)
 396                 ret = ret + ' with ' + self.__tree_like_builder.build_tag(s_desc)
 397                 ret = ret + ', and ' + self.__tree_like_builder.build_node_update(s_desc)
 398                 return ret
 399
 400 class lu_desc_to_html_builder:
 401         def build(self, s_desc):
 402                 ret = build_value_to_pb_ds_class_href(s_desc)
 403                 ret = ret + ' with ' + make_tt('Update_Policy')
 404                 ret = ret + ' = '
 405                 update_policy_desc = s_desc.getElementsByTagName('Update_Policy')[0]
 406                 ret = ret + build_value_to_pb_ds_class_href(update_policy_desc)
 407                 return ret
 408
 409
 410 class std_desc_to_html_builder:
 411         def build(self, s_desc):
 412                 value = s_desc.attributes['value'].value
 413                 return make_tt(value.replace('std_', 'std::'))
 414
 415
 416 class std_tr1_desc_to_html_builder:
 417         def build(self, s_desc):
 418                 value = s_desc.attributes['value'].value
 419                 ret =  make_tt(value.replace('std_tr1_', 'std::tr1::'))
 420                 ret = ret + ' with ' + make_tt('cache_hash_code')
 421                 ret = ret + ' = '
 422                 cache_hash_code = s_desc.getElementsByTagName('cache_hash_code')[0].attributes['value'].value
 423                 ret = ret + make_ttb(cache_hash_code)
 424                 return ret
 425
 426 class gnucxx_desc_to_html_builder:
 427         def build(self, s_desc):
 428                 value = s_desc.attributes['value'].value
 429                 return make_tt(value.replace('__gnucxx_', '__gnucxx::'))
 430
 431 class stdext_desc_to_html_builder:
 432         def build(self, s_desc):
 433                 value = s_desc.attributes['value'].value
 434                 return make_tt(value.replace('stdext_', 'stdext::'))
 435
 436 class npq_desc_to_html_builder:
 437         def build(self, vector):
 438                 if vector:
 439                         under = make_tt('std::vector')
 440                 else:
 441                         under = make_tt('std::deque')
 442
 443                 return make_tt('std::priority_queue') + ' adapting ' + under
 444
 445 class binary_heap_desc_to_html_builder:
 446         def build(self, s_desc):
 447                 ret = make_pb_ds_class_href('priority_queue')
 448                 ret = ret + ' with ' + make_tt('Tag')
 449                 ret = ret + ' = ' + make_pb_ds_class_href('binary_heap_tag')
 450                 return ret
 451
 452 class thin_heap_desc_to_html_builder:
 453         def build(self, s_desc):
 454                 ret = make_pb_ds_class_href('priority_queue')
 455                 ret = ret + ' with ' + make_tt('Tag')
 456                 ret = ret + ' = ' + make_pb_ds_class_href('thin_heap_tag')
 457                 return ret
 458
 459 class binomial_heap_desc_to_html_builder:
 460         def build(self, s_desc):
 461                 ret = make_pb_ds_class_href('priority_queue')
 462                 ret = ret + ' with ' + make_tt('Tag')
 463                 ret = ret + ' = ' + make_pb_ds_class_href('binomial_heap_tag')
 464                 return ret
 465
 466 class rc_binomial_heap_desc_to_html_builder:
 467         def build(self, s_desc):
 468                 ret = make_pb_ds_class_href('priority_queue')
 469                 ret = ret + ' with ' + make_tt('Tag')
 470                 ret = ret + ' = ' + make_pb_ds_class_href('rc_binomial_heap_tag')
 471                 return ret
 472
 473 class pairing_heap_desc_to_html_builder:
 474         def build(self, s_desc):
 475                 ret = make_pb_ds_class_href('priority_queue')
 476                 ret = ret + ' with ' + make_tt('Tag')
 477                 ret = ret + ' = ' + make_pb_ds_class_href('pairing_heap_tag')
 478                 return ret
 479
 480 class legend_desc_builder:
 481         """
 482         Returns a string corresponding to a specific container type.
 483         """
 484         def __init__(self):
 485                 self.__cc_hash_builder = cc_hash_desc_to_html_builder()
 486                 self.__gp_hash_builder = gp_hash_desc_to_html_builder()
 487                 self.__basic_tree_builder = basic_tree_desc_to_html_builder()
 488                 self.__basic_trie_builder = basic_trie_desc_to_html_builder()
 489                 self.__lu_builder = lu_desc_to_html_builder()
 490                 self.__std_builder = std_desc_to_html_builder()
 491                 self.__std_tr1_builder = std_tr1_desc_to_html_builder()
 492                 self.__gnucxx_builder = gnucxx_desc_to_html_builder()
 493                 self.__stdext_builder = stdext_desc_to_html_builder()
 494                 self.__npq_builder = npq_desc_to_html_builder()
 495                 self.__thin_heap_builder = thin_heap_desc_to_html_builder()
 496                 self.__thin_heap_builder = thin_heap_desc_to_html_builder()
 497                 self.__binary_heap_builder = binary_heap_desc_to_html_builder()
 498                 self.__binomial_heap_builder = binomial_heap_desc_to_html_builder()
 499                 self.__rc_binomial_heap_builder = rc_binomial_heap_desc_to_html_builder()
 500                 self.__pairing_heap_builder = pairing_heap_desc_to_html_builder()
 501
 502         def __build_specific(self, s_desc):
 503                 type = s_desc.attributes['value'].value
 504
 505                 if type == 'thin_heap':
 506                         return self.__thin_heap_builder.build(s_desc)
 507                 if type == 'binary_heap':
 508                         return self.__binary_heap_builder.build(s_desc)
 509                 if type == 'binomial_heap':
 510                         return self.__binomial_heap_builder.build(s_desc)
 511                 if type == 'rc_binomial_heap':
 512                         return self.__rc_binomial_heap_builder.build(s_desc)
 513                 if type == 'pairing_heap':
 514                         return self.__pairing_heap_builder.build(s_desc)
 515                 if type == 'cc_hash_table':
 516                         ret = self.__cc_hash_builder.build(s_desc)
 517                 elif type == 'gp_hash_table':
 518                         ret = self.__gp_hash_builder.build(s_desc)
 519                 elif type == 'tree':
 520                         ret = self.__basic_tree_builder.build(s_desc)
 521                 elif type == 'trie':
 522                         ret = self.__basic_trie_builder.build(s_desc)
 523                 elif type == 'list_update':
 524                         ret = self.__lu_builder.build(s_desc)
 525                 elif type == 'std::priority_queue_vector':
 526                         return self.__npq_builder.build(True)
 527                 elif type == 'std::priority_queue_deque':
 528                         return self.__npq_builder.build(False)
 529                 elif type == 'std_set' or type == 'std_map' or type == 'std_multimap':
 530                         return self.__std_builder.build(s_desc)
 531                 elif type == 'std_tr1_unordered_set' or type == 'std_tr1_unordered_map':
 532                         return self.__std_tr1_builder.build(s_desc)
 533                 elif type == 'stdext_hash_set' or type == 'stdext_hash_map' or type == 'stdext_hash_multimap':
 534                         return self.__stdext_builder.build(s_desc)
 535                 elif type == '__gnucxx_hash_set' or type == '__gnucxx_hash_map' or type == '__gnucxx_hash_multimap':
 536                         return self.__gnucxx_builder.build(s_desc)
 537                 else:
 538                         sys.stderr.write('cannot recognize %s\n' % type)
 539                         raise exception
 540                 return ret
 541
 542
 543         def build(self, desc):
 544                 s_descs = desc.getElementsByTagName('type')
 545                 if s_descs.length == 0:
 546                         print desc.toxml()
 547                         raise exception
 548                 ret = ''
 549                 count = 0
 550                 for s_desc in s_descs:
 551                         if count > 0:
 552                                 ret = ret + ', mapping each key to '
 553                         ret = ret + self.__build_specific(s_desc)
 554                         count = count + 1
 555                 return ret
 556
 557
 558 def main(doc_dir, res_dir, test_infos_f_name, test_name, build_name):
 559         res_gtr = res_getter(test_infos_f_name)
 560         res = res_gtr.get(res_dir, test_name)
 561         png_mkr = png_maker()
 562 #       png_of_name = doc_dir + '/' + test_name + '_' + build_name + '.png'
 563         png_of_name = doc_dir + '/' + test_name + '_' + build_name + '.svg'
 564         print png_of_name
 565         png_mkr.make(res, png_of_name)
 566
 567
 568 if __name__ == "__main__":
 569         """
 570         This module takes 6 parameters from the command line:
 571         Docs directory
 572         Results directory
 573         Tests info XML file name
 574         Test name
 575         Build name
 576         Compiler name
 577         """
 578         usg = "make_graph.py <doc_dir> <res_dir> <test_info_file> <test_name> <build_name>\n"
 579         if len(sys.argv) != 6:
 580                 sys.stderr.write(usg)
 581                 raise exception
 582         main(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5])