1 # coding=utf-8 2 # 3 # Copyright 2015 Intel Corporation 4 # 5 # Permission is hereby granted, free of charge, to any person obtaining a 6 # copy of this software and associated documentation files (the "Software"), 7 # to deal in the Software without restriction, including without limitation 8 # the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 # and/or sell copies of the Software, and to permit persons to whom the 10 # Software is furnished to do so, subject to the following conditions: 11 # 12 # The above copyright notice and this permission notice (including the next 13 # paragraph) shall be included in all copies or substantial portions of the 14 # Software. 15 # 16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 22 # IN THE SOFTWARE. 23 # 24 25 import sys 26 import xml.etree.ElementTree as ET 27 28 # We generate a static hash table for entry point lookup 29 # (vkGetProcAddress). We use a linear congruential generator for our hash 30 # function and a power-of-two size table. The prime numbers are determined 31 # experimentally. 32 33 none = 0xffff 34 hash_size = 256 35 u32_mask = 2**32 - 1 36 hash_mask = hash_size - 1 37 38 prime_factor = 5024183 39 prime_step = 19 40 41 def hash(name): 42 h = 0; 43 for c in name: 44 h = (h * prime_factor + ord(c)) & u32_mask 45 46 return h 47 48 def print_guard_start(guard): 49 if guard is not None: 50 print "#ifdef {0}".format(guard) 51 52 def print_guard_end(guard): 53 if guard is not None: 54 print "#endif // {0}".format(guard) 55 56 opt_header = False 57 opt_code = False 58 59 if (sys.argv[1] == "header"): 60 opt_header = True 61 sys.argv.pop() 62 elif (sys.argv[1] == "code"): 63 opt_code = True 64 sys.argv.pop() 65 66 # Extract the entry points from the registry 67 def get_entrypoints(doc, entrypoints_to_defines): 68 entrypoints = [] 69 commands = doc.findall('./commands/command') 70 for i, command in enumerate(commands): 71 type = command.find('./proto/type').text 72 fullname = command.find('./proto/name').text 73 shortname = fullname[2:] 74 params = map(lambda p: "".join(p.itertext()), command.findall('./param')) 75 params = ', '.join(params) 76 if fullname in entrypoints_to_defines: 77 guard = entrypoints_to_defines[fullname] 78 else: 79 guard = None 80 entrypoints.append((type, shortname, params, i, hash(fullname), guard)) 81 return entrypoints 82 83 # Maps entry points to extension defines 84 def get_entrypoints_defines(doc): 85 entrypoints_to_defines = {} 86 extensions = doc.findall('./extensions/extension') 87 for extension in extensions: 88 define = extension.get('protect') 89 entrypoints = extension.findall('./require/command') 90 for entrypoint in entrypoints: 91 fullname = entrypoint.get('name') 92 entrypoints_to_defines[fullname] = define 93 return entrypoints_to_defines 94 95 doc = ET.parse(sys.stdin) 96 entrypoints = get_entrypoints(doc, get_entrypoints_defines(doc)) 97 98 # For outputting entrypoints.h we generate a radv_EntryPoint() prototype 99 # per entry point. 100 101 if opt_header: 102 print "/* This file generated from vk_gen.py, don't edit directly. */\n" 103 104 print "struct radv_dispatch_table {" 105 print " union {" 106 print " void *entrypoints[%d];" % len(entrypoints) 107 print " struct {" 108 109 for type, name, args, num, h, guard in entrypoints: 110 if guard is not None: 111 print "#ifdef {0}".format(guard) 112 print " PFN_vk{0} {0};".format(name) 113 print "#else" 114 print " void *{0};".format(name) 115 print "#endif" 116 else: 117 print " PFN_vk{0} {0};".format(name) 118 print " };\n" 119 print " };\n" 120 print "};\n" 121 122 for type, name, args, num, h, guard in entrypoints: 123 print_guard_start(guard) 124 print "%s radv_%s(%s);" % (type, name, args) 125 print_guard_end(guard) 126 exit() 127 128 129 130 print """/* 131 * Copyright 2015 Intel Corporation 132 * 133 * Permission is hereby granted, free of charge, to any person obtaining a 134 * copy of this software and associated documentation files (the "Software"), 135 * to deal in the Software without restriction, including without limitation 136 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 137 * and/or sell copies of the Software, and to permit persons to whom the 138 * Software is furnished to do so, subject to the following conditions: 139 * 140 * The above copyright notice and this permission notice (including the next 141 * paragraph) shall be included in all copies or substantial portions of the 142 * Software. 143 * 144 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 145 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 146 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 147 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 148 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 149 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 150 * IN THE SOFTWARE. 151 */ 152 153 /* DO NOT EDIT! This is a generated file. */ 154 155 #include "radv_private.h" 156 157 struct radv_entrypoint { 158 uint32_t name; 159 uint32_t hash; 160 }; 161 162 /* We use a big string constant to avoid lots of reloctions from the entry 163 * point table to lots of little strings. The entries in the entry point table 164 * store the index into this big string. 165 */ 166 167 static const char strings[] =""" 168 169 offsets = [] 170 i = 0; 171 for type, name, args, num, h, guard in entrypoints: 172 print " \"vk%s\\0\"" % name 173 offsets.append(i) 174 i += 2 + len(name) + 1 175 print " ;" 176 177 # Now generate the table of all entry points 178 179 print "\nstatic const struct radv_entrypoint entrypoints[] = {" 180 for type, name, args, num, h, guard in entrypoints: 181 print " { %5d, 0x%08x }," % (offsets[num], h) 182 print "};\n" 183 184 print """ 185 186 /* Weak aliases for all potential implementations. These will resolve to 187 * NULL if they're not defined, which lets the resolve_entrypoint() function 188 * either pick the correct entry point. 189 */ 190 """ 191 192 for layer in [ "radv" ]: 193 for type, name, args, num, h, guard in entrypoints: 194 print_guard_start(guard) 195 print "%s %s_%s(%s) __attribute__ ((weak));" % (type, layer, name, args) 196 print_guard_end(guard) 197 print "\nconst struct radv_dispatch_table %s_layer = {" % layer 198 for type, name, args, num, h, guard in entrypoints: 199 print_guard_start(guard) 200 print " .%s = %s_%s," % (name, layer, name) 201 print_guard_end(guard) 202 print "};\n" 203 204 print """ 205 206 void * __attribute__ ((noinline)) 207 radv_resolve_entrypoint(uint32_t index) 208 { 209 return radv_layer.entrypoints[index]; 210 } 211 """ 212 213 # Now generate the hash table used for entry point look up. This is a 214 # uint16_t table of entry point indices. We use 0xffff to indicate an entry 215 # in the hash table is empty. 216 217 map = [none for f in xrange(hash_size)] 218 collisions = [0 for f in xrange(10)] 219 for type, name, args, num, h, guard in entrypoints: 220 level = 0 221 while map[h & hash_mask] != none: 222 h = h + prime_step 223 level = level + 1 224 if level > 9: 225 collisions[9] += 1 226 else: 227 collisions[level] += 1 228 map[h & hash_mask] = num 229 230 print "/* Hash table stats:" 231 print " * size %d entries" % hash_size 232 print " * collisions entries" 233 for i in xrange(10): 234 if (i == 9): 235 plus = "+" 236 else: 237 plus = " " 238 239 print " * %2d%s %4d" % (i, plus, collisions[i]) 240 print " */\n" 241 242 print "#define none 0x%04x\n" % none 243 244 print "static const uint16_t map[] = {" 245 for i in xrange(0, hash_size, 8): 246 print " ", 247 for j in xrange(i, i + 8): 248 if map[j] & 0xffff == 0xffff: 249 print " none,", 250 else: 251 print "0x%04x," % (map[j] & 0xffff), 252 print 253 254 print "};" 255 256 # Finally we generate the hash table lookup function. The hash function and 257 # linear probing algorithm matches the hash table generated above. 258 259 print """ 260 void * 261 radv_lookup_entrypoint(const char *name) 262 { 263 static const uint32_t prime_factor = %d; 264 static const uint32_t prime_step = %d; 265 const struct radv_entrypoint *e; 266 uint32_t hash, h, i; 267 const char *p; 268 269 hash = 0; 270 for (p = name; *p; p++) 271 hash = hash * prime_factor + *p; 272 273 h = hash; 274 do { 275 i = map[h & %d]; 276 if (i == none) 277 return NULL; 278 e = &entrypoints[i]; 279 h += prime_step; 280 } while (e->hash != hash); 281 282 if (strcmp(name, strings + e->name) != 0) 283 return NULL; 284 285 return radv_resolve_entrypoint(i); 286 } 287 """ % (prime_factor, prime_step, hash_mask) 288
