![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memory-auto.sh CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / libtme|
Return to memory-auto.sh CVS log | Up to [The Machine Emulator] / tme / libtme |
1.1 ! root 1: #! /bin/sh ! 2: ! 3: # $Id: memory-auto.sh,v 1.1 2006/09/30 12:43:37 fredette Exp $ ! 4: ! 5: # libtme/memory-auto.sh - automatically generates C code for ! 6: # memory support: ! 7: ! 8: # ! 9: # Copyright (c) 2005, 2006 Matt Fredette ! 10: # All rights reserved. ! 11: # ! 12: # Redistribution and use in source and binary forms, with or without ! 13: # modification, are permitted provided that the following conditions ! 14: # are met: ! 15: # 1. Redistributions of source code must retain the above copyright ! 16: # notice, this list of conditions and the following disclaimer. ! 17: # 2. Redistributions in binary form must reproduce the above copyright ! 18: # notice, this list of conditions and the following disclaimer in the ! 19: # documentation and/or other materials provided with the distribution. ! 20: # 3. All advertising materials mentioning features or use of this software ! 21: # must display the following acknowledgement: ! 22: # This product includes software developed by Matt Fredette. ! 23: # 4. The name of the author may not be used to endorse or promote products ! 24: # derived from this software without specific prior written permission. ! 25: # ! 26: # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 27: # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 28: # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 29: # DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 30: # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 31: # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 32: # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 33: # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 34: # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 35: # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 36: # POSSIBILITY OF SUCH DAMAGE. ! 37: # ! 38: ! 39: header=false ! 40: ! 41: for option ! 42: do ! 43: case $option in ! 44: --header) header=true ;; ! 45: esac ! 46: done ! 47: ! 48: PROG=`basename $0` ! 49: cat <<EOF ! 50: /* automatically generated by $PROG, do not edit! */ ! 51: ! 52: /* ! 53: * Copyright (c) 2005, 2006 Matt Fredette ! 54: * All rights reserved. ! 55: * ! 56: * Redistribution and use in source and binary forms, with or without ! 57: * modification, are permitted provided that the following conditions ! 58: * are met: ! 59: * 1. Redistributions of source code must retain the above copyright ! 60: * notice, this list of conditions and the following disclaimer. ! 61: * 2. Redistributions in binary form must reproduce the above copyright ! 62: * notice, this list of conditions and the following disclaimer in the ! 63: * documentation and/or other materials provided with the distribution. ! 64: * 3. All advertising materials mentioning features or use of this software ! 65: * must display the following acknowledgement: ! 66: * This product includes software developed by Matt Fredette. ! 67: * 4. The name of the author may not be used to endorse or promote products ! 68: * derived from this software without specific prior written permission. ! 69: * ! 70: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 71: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 72: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 73: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 74: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 75: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 76: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 77: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 78: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 79: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 80: * POSSIBILITY OF SUCH DAMAGE. ! 81: */ ! 82: EOF ! 83: ! 84: if $header; then :; else ! 85: cat <<EOF ! 86: ! 87: /* includes: */ ! 88: #include <tme/memory.h> ! 89: ! 90: EOF ! 91: fi ! 92: cat <<EOF ! 93: ! 94: _TME_RCSID("\$Id: memory-auto.sh,v 1.1 2006/09/30 12:43:37 fredette Exp $"); ! 95: EOF ! 96: if $header; then ! 97: cat <<EOF ! 98: ! 99: /* macros: */ ! 100: ! 101: /* the plain partial read internal macro: */ ! 102: #define _tme_memory_read(type_whole, type_part, mem, offset) \\ ! 103: (((type_whole) \\ ! 104: *((_tme_const type_part *) \\ ! 105: (_tme_cast_pointer_const(tme_uint8_t *, type_whole *, mem) \\ ! 106: + (offset)))) \\ ! 107: << (8 * (TME_ENDIAN_NATIVE == TME_ENDIAN_BIG \\ ! 108: ? (sizeof(type_whole) \\ ! 109: - ((offset) + sizeof(type_part))) \\ ! 110: : (offset)))) ! 111: ! 112: /* the plain partial write internal macro: */ ! 113: #define _tme_memory_write(type_whole, type_part, mem, offset, x) \\ ! 114: do { \\ ! 115: *((type_part *) \\ ! 116: (_tme_cast_pointer(tme_uint8_t *, type_whole *, mem) \\ ! 117: + (offset))) \\ ! 118: = (((type_whole) (x)) \\ ! 119: >> (8 * (TME_ENDIAN_NATIVE == TME_ENDIAN_BIG \\ ! 120: ? (sizeof(type_whole) \\ ! 121: - ((offset) + sizeof(type_part))) \\ ! 122: : (offset)))); \\ ! 123: } while (/* CONSTCOND */ 0) ! 124: ! 125: /* this tests bits in a memory address: */ ! 126: #define _tme_memory_address_test(mem, bits, align_min) \\ ! 127: (((bits) & ~((align_min - 1))) & ((unsigned long) (mem))) ! 128: ! 129: /* this returns a mask of all-bits-one in given type: */ ! 130: #define _tme_memory_type_mask(type, shift) \\ ! 131: ((type) ((((type) 0) - ((type) 1)) shift)) ! 132: ! 133: EOF ! 134: fi ! 135: ! 136: # the different sizes we handle, and the smallest size that we have to ! 137: # wrap in an ifdef: ! 138: # ! 139: sizes='8 16 32 64' ! 140: size_ifdef=64 ! 141: ! 142: # the largest possible host boundary that we will consider: ! 143: # ! 144: host_boundary_largest=64 ! 145: ! 146: # permute for the different sizes: ! 147: # ! 148: for size in ${sizes}; do ! 149: ! 150: # we don't need bus eight-bit read and write slow functions: ! 151: # ! 152: if test ${size} = 8; then continue; fi ! 153: ! 154: if test `expr ${size} \>= ${size_ifdef}` = 1; then ! 155: echo "" ! 156: echo "#ifdef TME_HAVE_INT${size}_T" ! 157: fi ! 158: ! 159: # emit the bus read and write slow functions: ! 160: # ! 161: for op in read write; do ! 162: ! 163: # dispatch on the operation: ! 164: # ! 165: if test ${op} = read; then ! 166: op_return_type="tme_uint${size}_t" ! 167: op_cap=READ ! 168: op_const="_tme_const " ! 169: op_proto_operand= ! 170: op_operand= ! 171: else ! 172: op_return_type=void ! 173: op_cap=WRITE ! 174: op_const= ! 175: op_proto_operand=", tme_uint${size}_t" ! 176: op_operand="${op_proto_operand} x" ! 177: fi ! 178: ! 179: # if we're making the header, just emit a prototype: ! 180: # ! 181: if $header; then ! 182: echo "" ! 183: echo "/* the bus ${size}-bit ${op} slow function: */" ! 184: echo "${op_return_type} tme_memory_bus_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int, unsigned int));" ! 185: continue ! 186: fi ! 187: ! 188: echo "" ! 189: echo "/* undefine the macro version of tme_memory_bus_${op}${size}: */" ! 190: echo "#undef tme_memory_bus_${op}${size}" ! 191: echo "" ! 192: echo "/* the bus ${size}-bit ${op} slow function: */" ! 193: echo ${op_return_type} ! 194: echo "tme_memory_bus_${op}${size}(${op_const}tme_shared tme_uint${size}_t *mem${op_operand}, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)" ! 195: echo "{" ! 196: echo " const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;" ! 197: echo " unsigned int size_skip;" ! 198: echo " unsigned int size_done;" ! 199: if test ${op} = read; then ! 200: echo " tme_uint${size}_t x;" ! 201: fi ! 202: ! 203: # emit the locals for the possible host boundaries: ! 204: # ! 205: host_boundary=${host_boundary_largest} ! 206: while test ${host_boundary} != 4; do ! 207: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 208: echo "#ifdef TME_HAVE_INT${host_boundary}_T" ! 209: fi ! 210: echo " ${op_const}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};" ! 211: echo " tme_uint${host_boundary}_t part${host_boundary};" ! 212: if test ${op} = write; then ! 213: echo " tme_uint${host_boundary}_t part${host_boundary}_cmp;" ! 214: fi ! 215: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 216: echo "#endif /* TME_HAVE_INT${host_boundary}_T */" ! 217: fi ! 218: host_boundary=`expr ${host_boundary} / 2` ! 219: done ! 220: echo "" ! 221: echo -n " assert (bus_boundary != 0 && bus_boundary <= host_boundary);" ! 222: ! 223: # loop over the possible host boundaries: ! 224: # ! 225: host_boundary=${host_boundary_largest} ! 226: while test ${host_boundary} != 4; do ! 227: ! 228: # calculate the worst number of host boundaries that an ! 229: # access of this size could cross: ! 230: # ! 231: host_boundaries_worst=`expr ${size} - 16` ! 232: host_boundaries_worst=`expr ${host_boundaries_worst} / ${host_boundary}` ! 233: host_boundaries_worst=`expr ${host_boundaries_worst} + 1` ! 234: ! 235: # open this host boundary: ! 236: # ! 237: if test ${host_boundary} != 8; then ! 238: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 239: echo "" ! 240: echo "" ! 241: echo "#ifdef TME_HAVE_INT${host_boundary}_T" ! 242: echo "" ! 243: echo -n " " ! 244: fi ! 245: echo -n " if (host_boundary == sizeof(tme_uint${host_boundary}_t))" ! 246: fi ! 247: echo " {" ! 248: ! 249: echo "" ! 250: echo " /* prepare to ${op} the first ${host_boundary}-bit part of the memory: */" ! 251: echo " parts${host_boundary} = (${op_const}tme_shared tme_uint${host_boundary}_t *) (((unsigned long) mem) & (((unsigned long) 0) - (${host_boundary} / 8)));" ! 252: echo " size_skip = (((unsigned int) (unsigned long) mem) % (${host_boundary} / 8)) * 8;" ! 253: echo " size_done = 0;" ! 254: ! 255: echo "" ! 256: echo " /* ${op} the first ${host_boundary}-bit part of the memory: */" ! 257: ! 258: # emit two accesses. if the worst number of boundaries ! 259: # that this access could cross is one, the second access ! 260: # is inside an if, else it's in a for loop: ! 261: # ! 262: indent0= ! 263: size_done=0 ! 264: size_skip=size_skip ! 265: access_or= ! 266: while true; do ! 267: ! 268: # read this memory part: ! 269: # ! 270: echo "${indent0} part${host_boundary} = tme_memory_atomic_read${host_boundary}(parts${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));" ! 271: ! 272: # if this is a read: ! 273: # ! 274: if test ${op} = read; then ! 275: ! 276: echo "" ! 277: echo "${indent0} /* on a little-endian host, we shift off the skip" ! 278: echo "${indent0} data on the right, and shift the remaining data" ! 279: echo "${indent0} up into position in the result: */" ! 280: echo "${indent0} if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {" ! 281: echo "${indent0} x ${access_or}= (((tme_uint${size}_t) (part${host_boundary} >> ${size_skip})) << ${size_done});" ! 282: echo "${indent0} }" ! 283: echo "" ! 284: echo "${indent0} /* on a big-endian host, we shift off the skip data" ! 285: echo "${indent0} on the left, and shift the remaining data down" ! 286: echo "${indent0} into position in the result: */" ! 287: # ! 288: # NB: on a big-endian host, because the skip data ! 289: # is on the left, the type of what we shift ! 290: # depends on how this host boundary size compares ! 291: # to the access size: ! 292: # ! 293: echo "${indent0} else {" ! 294: echo -n "${indent0} x ${access_or}= " ! 295: if test `expr ${host_boundary} \> ${size}` = 1; then ! 296: echo "((part${host_boundary} << ${size_skip}) >> ((${host_boundary} - ${size}) + ${size_done}));" ! 297: else ! 298: echo "((((tme_uint${size}_t) part${host_boundary}) << ((${size} - ${host_boundary}) + ${size_skip})) >> ${size_done});" ! 299: fi ! 300: echo "${indent0} }" ! 301: ! 302: # otherwise, this is a write: ! 303: # ! 304: else ! 305: ! 306: # start the compare-and-exchange do loop: ! 307: # ! 308: echo "${indent0} do {" ! 309: echo "${indent0} part${host_boundary}_cmp = part${host_boundary};" ! 310: echo "" ! 311: echo "${indent0} /* on a little-endian host, we clear with zeroes" ! 312: echo "${indent0} shifted up past the skip data, and then we" ! 313: echo "${indent0} insert the data shifted up past the skip data: */" ! 314: echo "${indent0} if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {" ! 315: echo "${indent0} part${host_boundary} &= (_tme_memory_type_mask(tme_uint${host_boundary}_t, + 0) ^ (((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, << ${size_done})) << ${size_skip}));" ! 316: echo "${indent0} part${host_boundary} |= (((tme_uint${host_boundary}_t) x) << ${size_skip});" ! 317: echo "${indent0} }" ! 318: echo "" ! 319: echo "${indent0} /* on a big-endian host, we clear with zeroes" ! 320: echo "${indent0} shifted down past the skip data, and then we" ! 321: echo "${indent0} insert the data shifted down past the skip data: */" ! 322: # ! 323: # NB: on a big-endian host, because the skip data ! 324: # is on the left, exactly how we shift depends on ! 325: # how this host boundary size compares to the ! 326: # access size: ! 327: # ! 328: echo "${indent0} else {" ! 329: if test `expr ${host_boundary} \> ${size}` = 1; then ! 330: echo "${indent0} part${host_boundary} &= ~((((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, + 0)) << ((${host_boundary} - ${size}) + ${size_done})) >> ${size_skip});" ! 331: echo "${indent0} part${host_boundary} |= ((((tme_uint${host_boundary}_t) x) << (${host_boundary} - ${size})) >> ${size_skip});" ! 332: else ! 333: echo "${indent0} part${host_boundary} &= ~(_tme_memory_type_mask(tme_uint${host_boundary}_t, << ${size_done}) >> ${size_skip});" ! 334: echo "${indent0} part${host_boundary} |= (x >> ((${size} - ${host_boundary}) + ${size_skip}));" ! 335: fi ! 336: echo "${indent0} }" ! 337: echo "" ! 338: echo "${indent0} /* loop until we can atomically update this part: */" ! 339: echo "${indent0} part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));" ! 340: echo "${indent0} } while (part${host_boundary} != part${host_boundary}_cmp);" ! 341: if test ${host_boundaries_worst} != 1 || test ${size_skip} != 0; then ! 342: echo "${indent0} if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {" ! 343: echo "${indent0} x >>= (${host_boundary} - ${size_skip});" ! 344: echo "${indent0} }" ! 345: echo "${indent0} else {" ! 346: echo "${indent0} x <<= (${host_boundary} - ${size_skip});" ! 347: echo "${indent0} }" ! 348: fi ! 349: fi ! 350: ! 351: # if this was the first access: ! 352: # ! 353: if test ${size_done} = 0; then ! 354: ! 355: echo " size_done = ${host_boundary} - size_skip;" ! 356: size_done=size_done ! 357: size_skip=0 ! 358: access_or='|' ! 359: ! 360: # if the worst number of boundaries that this ! 361: # access could cross is more than one, we will do ! 362: # the remaining accesses in a loop, otherwise we ! 363: # will do one more access, if necessary: ! 364: # ! 365: if test ${host_boundaries_worst} = 1; then ! 366: access_if=true ! 367: else ! 368: access_if=false ! 369: ! 370: # as an optimization, writes of full parts are ! 371: # done directly: ! 372: # ! 373: if test ${op} = write; then ! 374: if test `expr ${host_boundary} \< ${size}` = 1; then ! 375: echo "" ! 376: if test ${host_boundaries_worst} = 2; then ! 377: echo " /* try to write one full ${host_boundary}-bit part of memory: */" ! 378: echo -n " if (__tme_predict_true(size_done <= (${size} - ${host_boundary})))" ! 379: else ! 380: echo " /* write as many full ${host_boundary}-bit parts of the memory as we can: */" ! 381: echo -n " for (; size_done <= (${size} - ${host_boundary}); )" ! 382: fi ! 383: echo " {" ! 384: echo "" ! 385: echo " /* make a boundary: */" ! 386: echo " tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});" ! 387: echo "" ! 388: echo " /* write a full ${host_boundary}-bit part of memory: */" ! 389: echo " part${host_boundary} = (x >> ((TME_ENDIAN_NATIVE == TME_ENDIAN_BIG) * (${size} - ${host_boundary})));" ! 390: echo " parts${host_boundary}++;" ! 391: echo " tme_memory_atomic_write${host_boundary}(parts${host_boundary}, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));" ! 392: echo " size_done += ${host_boundary};" ! 393: echo " if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {" ! 394: echo " x >>= ${host_boundary};" ! 395: echo " }" ! 396: echo " else {" ! 397: echo " x <<= ${host_boundary};" ! 398: echo " }" ! 399: echo " }" ! 400: access_if=true ! 401: fi ! 402: fi ! 403: fi ! 404: echo "" ! 405: if $access_if; then ! 406: echo " /* ${op} at most one remaining ${host_boundary}-bit part of the memory: */" ! 407: echo -n " if (__tme_predict_false(size_done < ${size}))" ! 408: else ! 409: echo " /* ${op} any remaining ${host_boundary}-bit parts of the memory: */" ! 410: echo -n " for (; size_done < ${size}; size_done += ${host_boundary})" ! 411: fi ! 412: echo " {" ! 413: ! 414: echo "" ! 415: echo " /* make a boundary: */" ! 416: echo " tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});" ! 417: echo "" ! 418: echo " /* ${op} the next ${host_boundary}-bit part of the memory: */" ! 419: echo " parts${host_boundary}++;" ! 420: indent0=" " ! 421: ! 422: # otherwise, this was the loop or second access: ! 423: # ! 424: else ! 425: echo " }" ! 426: break ! 427: fi ! 428: ! 429: done ! 430: ! 431: echo " }" ! 432: ! 433: # close this host boundary: ! 434: # ! 435: if test ${host_boundary} != 8; then ! 436: echo "" ! 437: echo -n " else" ! 438: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 439: echo "" ! 440: echo "" ! 441: echo -n "#endif /* TME_HAVE_INT${host_boundary}_T */" ! 442: if test ${host_boundary} = ${size_ifdef}; then ! 443: echo "" ! 444: echo "" ! 445: echo -n " " ! 446: fi ! 447: fi ! 448: fi ! 449: ! 450: # advance: ! 451: # ! 452: host_boundary=`expr ${host_boundary} / 2` ! 453: done ! 454: if test ${op} = read; then ! 455: echo "" ! 456: echo " /* return the value read: */" ! 457: echo " return (x);" ! 458: fi ! 459: echo "}" ! 460: done ! 461: ! 462: if test `expr ${size} \>= ${size_ifdef}` = 1; then ! 463: echo "" ! 464: echo "#endif /* TME_HAVE_INT${size}_T */" ! 465: fi ! 466: ! 467: done ! 468: ! 469: # emit the bus read and write buffer functions: ! 470: # ! 471: for op in read write; do ! 472: ! 473: # dispatch on the operation: ! 474: # ! 475: if test ${op} = read; then ! 476: op_cap=READ ! 477: op_rwlock=rd ! 478: op_const_mem="_tme_const " ! 479: op_const_buffer= ! 480: op_audit_mem= ! 481: op_audit_buffer=_tme_audit_pointer ! 482: op_memcpy="(buffer), ((_tme_const tme_uint8_t *) (mem))" ! 483: op_copy="*buffer = *part_buffer" ! 484: else ! 485: op_cap=WRITE ! 486: op_rwlock=wr ! 487: op_const_mem= ! 488: op_const_buffer="_tme_const " ! 489: op_audit_mem=_tme_audit_pointer_shared ! 490: op_audit_buffer=_tme_audit_pointer_const ! 491: op_memcpy="(tme_uint8_t *) (mem), (buffer)" ! 492: op_copy="*part_buffer = *buffer" ! 493: fi ! 494: ! 495: # if we're making the header: ! 496: # ! 497: if $header; then ! 498: ! 499: echo "" ! 500: echo "/* the bus ${op} buffer function and default macro implementation: */" ! 501: ! 502: # emit the prototype: ! 503: # ! 504: echo "void tme_memory_bus_${op}_buffer _TME_P((${op_const_mem}tme_shared tme_uint8_t *, ${op_const_buffer}tme_uint8_t *, unsigned long, tme_rwlock_t *, unsigned int, unsigned int));" ! 505: ! 506: # emit the default macro definition: ! 507: # ! 508: echo "#define tme_memory_bus_${op}_buffer(mem, buffer, count, rwlock, align_min, bus_boundary) \\" ! 509: echo " do { \\" ! 510: echo " if (TME_THREADS_COOPERATIVE) { \\" ! 511: echo " memcpy(${op_memcpy}, (count)); \\" ! 512: echo " } \\" ! 513: echo " else { \\" ! 514: echo " tme_memory_bus_${op}_buffer(((${op_const_mem}tme_shared tme_uint8_t *) ${op_audit_mem}(mem)), ((${op_const_buffer}tme_uint8_t *) ${op_audit_buffer}(buffer)), (count), (rwlock), (align_min), (bus_boundary)); \\" ! 515: echo " } \\" ! 516: echo " } while (/* CONSTCOND */ 0)" ! 517: ! 518: continue ! 519: fi ! 520: ! 521: # start the function: ! 522: # ! 523: echo "" ! 524: echo "/* undefine the macro version of tme_memory_bus_${op}_buffer: */" ! 525: echo "#undef tme_memory_bus_${op}_buffer" ! 526: echo "" ! 527: echo "/* the bus ${op} buffer function: */" ! 528: echo "void" ! 529: echo "tme_memory_bus_${op}_buffer(${op_const_mem}tme_shared tme_uint8_t *mem, ${op_const_buffer}tme_uint8_t *buffer, unsigned long count, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)" ! 530: echo "{" ! 531: echo " const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;" ! 532: echo " ${op_const_mem}tme_uint8_t *part_buffer;" ! 533: echo " unsigned int count_done;" ! 534: echo " unsigned int count_misaligned;" ! 535: echo " unsigned int bits_misaligned;" ! 536: ! 537: # emit the locals for the possible host boundaries: ! 538: # ! 539: host_boundary=${host_boundary_largest} ! 540: while test ${host_boundary} != 4; do ! 541: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 542: echo "#ifdef TME_HAVE_INT${host_boundary}_T" ! 543: fi ! 544: echo " ${op_const}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};" ! 545: echo " tme_uint${host_boundary}_t part${host_boundary}_buffer;" ! 546: echo " tme_uint${host_boundary}_t part${host_boundary};" ! 547: echo " tme_uint${host_boundary}_t part${host_boundary}_next;" ! 548: if test ${op} = write; then ! 549: echo " tme_uint${host_boundary}_t part${host_boundary}_mask;" ! 550: echo " tme_uint${host_boundary}_t part${host_boundary}_cmp;" ! 551: fi ! 552: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 553: echo "#endif /* TME_HAVE_INT${host_boundary}_T */" ! 554: fi ! 555: host_boundary=`expr ${host_boundary} / 2` ! 556: done ! 557: echo "" ! 558: echo " assert (count != 0);" ! 559: echo " assert (bus_boundary != 0);" ! 560: ! 561: echo "" ! 562: echo " /* if we are locking for all memory accesses, lock memory" ! 563: echo " around a memcpy: */" ! 564: echo " if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {" ! 565: echo " tme_rwlock_${op_rwlock}lock(rwlock);" ! 566: echo " memcpy(${op_memcpy}, (count));" ! 567: echo " tme_rwlock_unlock(rwlock);" ! 568: echo " }" ! 569: echo "" ! 570: echo " /* otherwise, if the emulated bus boundary is greater than the" ! 571: echo " host's bus boundary, we are forced to stop all other threads" ! 572: echo " around a memcpy: */" ! 573: echo " else if (__tme_predict_false(bus_boundary == 0" ! 574: echo " || bus_boundary > host_boundary)) {" ! 575: echo " tme_thread_suspend_others();" ! 576: echo " memcpy(${op_memcpy}, (count) + (0 && align_min));" ! 577: echo " tme_thread_resume_others();" ! 578: echo " }" ! 579: ! 580: # loop over the possible host boundaries: ! 581: # ! 582: host_boundary=${host_boundary_largest} ! 583: indent0= ! 584: while test ${host_boundary} != 4; do ! 585: ! 586: # open this host boundary: ! 587: # ! 588: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 589: echo "" ! 590: echo "#ifdef TME_HAVE_INT${host_boundary}_T" ! 591: fi ! 592: echo "" ! 593: echo -n " else" ! 594: if test ${host_boundary} != 8; then ! 595: echo -n " if (host_boundary == sizeof(tme_uint${host_boundary}_t))" ! 596: fi ! 597: echo " {" ! 598: ! 599: if test ${op} = write; then ! 600: op_part_read="tme_memory_read${host_boundary}((const tme_uint${host_boundary}_t *) buffer, sizeof(tme_uint${host_boundary}_t))" ! 601: op_part_write="tme_memory_atomic_write${host_boundary}(parts${host_boundary}, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t))" ! 602: else ! 603: op_part_read="tme_memory_atomic_read${host_boundary}(parts${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t))" ! 604: op_part_write="tme_memory_write${host_boundary}((tme_uint${host_boundary}_t *) buffer, part${host_boundary}, sizeof(tme_uint${host_boundary}_t))" ! 605: fi ! 606: ! 607: echo "" ! 608: echo " /* make a ${host_boundary}-bit pointer to the memory: */" ! 609: echo " parts${host_boundary} = (${op_const}tme_shared tme_uint${host_boundary}_t *) mem;" ! 610: echo "" ! 611: echo " /* if this pointer is not ${host_boundary}-bit aligned: */" ! 612: echo " if (__tme_predict_false((((unsigned long) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t)) != 0)) {" ! 613: echo "" ! 614: echo " /* get the misalignment from the previous ${host_boundary}-bit boundary: */" ! 615: echo " count_misaligned = ((unsigned long) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t);" ! 616: echo "" ! 617: echo " /* truncate this pointer to the previous ${host_boundary}-bit boundary: */" ! 618: echo " parts${host_boundary} = (${op_const}tme_shared tme_uint${host_boundary}_t *) (((unsigned long) parts${host_boundary}) & (((unsigned long) 0) - sizeof(tme_uint${host_boundary}_t)));" ! 619: echo "" ! 620: echo " /* get the number of bytes to ${op} in the first ${host_boundary}-bit memory part: */" ! 621: echo " count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;" ! 622: echo " if (__tme_predict_false(count_done > count)) {" ! 623: echo " count_done = count;" ! 624: echo " }" ! 625: ! 626: if test ${op} = write; then ! 627: echo "" ! 628: echo " /* make a mask that clears for the data to write in the" ! 629: echo " first ${host_boundary}-bit memory part: */" ! 630: echo " part${host_boundary}_mask = 1;" ! 631: echo " part${host_boundary}_mask = (part${host_boundary}_mask << (count_done * 8)) - 1;" ! 632: echo " part${host_boundary}_mask" ! 633: echo " <<= (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE" ! 634: echo " ? (count_misaligned * 8)" ! 635: echo " : (${host_boundary} - ((count_misaligned + count_done) * 8)));" ! 636: echo " part${host_boundary}_mask = ~part${host_boundary}_mask;" ! 637: echo "" ! 638: echo " /* copy from the buffer the bytes to write in the first" ! 639: echo " ${host_boundary}-bit memory part: */" ! 640: echo " part${host_boundary}_buffer = 0;" ! 641: else ! 642: echo "" ! 643: echo " /* read the first ${host_boundary}-bit memory part: */" ! 644: echo " part${host_boundary}_buffer = ${op_part_read};" ! 645: echo " parts${host_boundary}++;" ! 646: echo "" ! 647: echo " /* copy to the buffer the bytes to read in the first" ! 648: echo " ${host_boundary}-bit memory part: */" ! 649: fi ! 650: echo " part_buffer = ((tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;" ! 651: echo " count -= count_done;" ! 652: echo " do {" ! 653: echo " ${op_copy};" ! 654: echo " part_buffer++;" ! 655: echo " buffer++;" ! 656: echo " } while (--count_done != 0);" ! 657: ! 658: if test ${op} = write; then ! 659: echo "" ! 660: echo " /* compare-and-exchange the first ${host_boundary}-bit memory part: */" ! 661: echo " part${host_boundary} = ${op_part_read};" ! 662: echo " do {" ! 663: echo " part${host_boundary}_cmp = part${host_boundary};" ! 664: echo " part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;" ! 665: echo " part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));" ! 666: echo " } while (part${host_boundary} != part${host_boundary}_cmp);" ! 667: echo " parts${host_boundary}++;" ! 668: fi ! 669: echo " }" ! 670: ! 671: echo "" ! 672: echo " /* if we have full ${host_boundary}-bit parts to ${op}: */" ! 673: echo " if (__tme_predict_true(count >= sizeof(tme_uint${host_boundary}_t))) {" ! 674: echo "" ! 675: echo " /* if the buffer is ${host_boundary}-bit aligned: */" ! 676: echo " if (__tme_predict_true((((unsigned long) buffer) % sizeof(tme_uint${host_boundary}_t)) == 0)) {" ! 677: echo "" ! 678: echo " /* ${op} full ${host_boundary}-bit parts without shifting: */" ! 679: echo " do {" ! 680: echo " part${host_boundary} = ${op_part_read};" ! 681: echo " ${op_part_write};" ! 682: echo "" ! 683: echo " /* advance: */" ! 684: echo " parts${host_boundary}++;" ! 685: echo " buffer += sizeof(tme_uint${host_boundary}_t);" ! 686: echo " count -= sizeof(tme_uint${host_boundary}_t);" ! 687: echo " } while (count >= sizeof(tme_uint${host_boundary}_t));" ! 688: echo " }" ! 689: echo "" ! 690: echo " /* otherwise, the buffer is not ${host_boundary}-bit aligned: */" ! 691: echo " else {" ! 692: echo "" ! 693: echo " /* get the misalignment to the next ${host_boundary}-bit boundary: */" ! 694: echo " count_misaligned = (sizeof(tme_uint${host_boundary}_t) - ((unsigned int) (unsigned long) buffer)) % sizeof(tme_uint${host_boundary}_t);" ! 695: if test ${op} = write; then ! 696: echo "" ! 697: echo " /* copy from the buffer until it is aligned: */" ! 698: echo " part${host_boundary}_buffer = 0;" ! 699: else ! 700: echo "" ! 701: echo " /* read the next ${host_boundary}-bit memory part: */" ! 702: echo " part${host_boundary}_buffer = ${op_part_read};" ! 703: echo " parts${host_boundary}++;" ! 704: echo "" ! 705: echo " /* copy to the buffer until it is aligned: */" ! 706: fi ! 707: echo " part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);" ! 708: echo " count_done = count_misaligned;" ! 709: echo " count -= count_misaligned;" ! 710: echo " do {" ! 711: echo " ${op_copy};" ! 712: echo " part_buffer++;" ! 713: echo " buffer++;" ! 714: echo " } while (--count_done != 0);" ! 715: ! 716: echo "" ! 717: echo " /* ${op} full ${host_boundary}-bit words with shifting: */" ! 718: echo " bits_misaligned = count_misaligned * 8;" ! 719: if test ${op} = write; then ! 720: op_shift=bits_misaligned ! 721: op_shift_next="(${host_boundary} - bits_misaligned)" ! 722: echo " part${host_boundary} = part${host_boundary}_buffer;" ! 723: else ! 724: op_shift="(${host_boundary} - bits_misaligned)" ! 725: op_shift_next=bits_misaligned ! 726: echo " part${host_boundary}" ! 727: echo " = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE" ! 728: echo " ? (part${host_boundary}_buffer >> ${op_shift_next})" ! 729: echo " : (part${host_boundary}_buffer << ${op_shift_next}));" ! 730: fi ! 731: echo " for (; count >= sizeof(tme_uint${host_boundary}_t); ) {" ! 732: echo " part${host_boundary}_next = ${op_part_read};" ! 733: echo " if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {" ! 734: echo " part${host_boundary} |= (part${host_boundary}_next << ${op_shift});" ! 735: echo " ${op_part_write};" ! 736: echo " part${host_boundary} = (part${host_boundary}_next >> ${op_shift_next});" ! 737: echo " }" ! 738: echo " else {" ! 739: echo " part${host_boundary} |= (part${host_boundary}_next >> ${op_shift});" ! 740: echo " ${op_part_write};" ! 741: echo " part${host_boundary} = (part${host_boundary}_next << ${op_shift_next});" ! 742: echo " }" ! 743: echo "" ! 744: echo " /* advance: */" ! 745: echo " parts${host_boundary}++;" ! 746: echo " buffer += sizeof(tme_uint${host_boundary}_t);" ! 747: echo " count -= sizeof(tme_uint${host_boundary}_t);" ! 748: echo " }" ! 749: ! 750: echo "" ! 751: echo " /* calculate how many more bytes there are to ${op} in this" ! 752: echo " ${host_boundary}-bit memory part: */" ! 753: echo " count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;" ! 754: echo " part${host_boundary}_buffer = part${host_boundary};" ! 755: if test ${op} = write; then ! 756: echo "" ! 757: echo " /* if we can't write one more full ${host_boundary}-bit memory part: */" ! 758: echo " if (count_done > count) {" ! 759: echo "" ! 760: echo " /* we will reread this data to write below: */" ! 761: echo " buffer -= count_misaligned;" ! 762: echo " count += count_misaligned;" ! 763: echo " }" ! 764: echo "" ! 765: echo " /* otherwise, we can write one more full ${host_boundary}-bit memory part: */" ! 766: echo " else {" ! 767: echo "" ! 768: echo " /* copy from the buffer until we have the full ${host_boundary}-bit part: */" ! 769: echo " part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;" ! 770: echo " count -= count_done;" ! 771: echo " do {" ! 772: echo " ${op_copy};" ! 773: echo " part_buffer++;" ! 774: echo " buffer++;" ! 775: echo " } while (--count_done != 0);" ! 776: echo "" ! 777: echo " /* write the last full ${host_boundary}-bit memory part: */" ! 778: echo " part${host_boundary} = part${host_boundary}_buffer;" ! 779: echo " ${op_part_write};" ! 780: echo " }" ! 781: else ! 782: echo "" ! 783: echo " /* copy to the buffer the remaining bytes in this ${host_boundary}-bit part: */" ! 784: echo " if (count_done > count) {" ! 785: echo " count_done = count;" ! 786: echo " }" ! 787: echo " part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);" ! 788: echo " count -= count_done;" ! 789: echo " do {" ! 790: echo " ${op_copy};" ! 791: echo " part_buffer++;" ! 792: echo " buffer++;" ! 793: echo " } while (--count_done != 0);" ! 794: fi ! 795: echo " }" ! 796: echo " }" ! 797: ! 798: echo "" ! 799: echo " /* if we still have bytes to ${op}: */" ! 800: echo " if (__tme_predict_false(count > 0)) {" ! 801: echo "" ! 802: echo " /* we must have less than a full ${host_boundary}-bit part to ${op}: */" ! 803: echo " assert (count < sizeof(tme_uint${host_boundary}_t));" ! 804: if test ${op} = write; then ! 805: echo "" ! 806: echo " /* make a mask that clears for the data to write in the last" ! 807: echo " ${host_boundary}-bit memory part: */" ! 808: echo " part${host_boundary}_mask" ! 809: echo " = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE" ! 810: echo " ? _tme_memory_type_mask(tme_uint${host_boundary}_t, << (count * 8))" ! 811: echo " : _tme_memory_type_mask(tme_uint${host_boundary}_t, >> (count * 8)));" ! 812: echo "" ! 813: echo " /* copy from the buffer the bytes to write in the last" ! 814: echo " ${host_boundary}-bit memory part: */" ! 815: echo " part${host_boundary}_buffer = 0;" ! 816: else ! 817: echo "" ! 818: echo " /* read the last ${host_boundary}-bit memory part: */" ! 819: echo " part${host_boundary}_buffer = ${op_part_read};" ! 820: echo "" ! 821: echo " /* copy to the buffer the bytes to read in the first" ! 822: echo " ${host_boundary}-bit memory part: */" ! 823: fi ! 824: echo " part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);" ! 825: echo " count_done = count;" ! 826: echo " do {" ! 827: echo " ${op_copy};" ! 828: echo " part_buffer++;" ! 829: echo " buffer++;" ! 830: echo " } while (--count_done != 0);" ! 831: if test ${op} = write; then ! 832: echo "" ! 833: echo " /* compare-and-exchange the last ${host_boundary}-bit memory part: */" ! 834: echo " part${host_boundary} = ${op_part_read};" ! 835: echo " do {" ! 836: echo " part${host_boundary}_cmp = part${host_boundary};" ! 837: echo " part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;" ! 838: echo " part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));" ! 839: echo " } while (part${host_boundary} != part${host_boundary}_cmp);" ! 840: fi ! 841: echo " }" ! 842: ! 843: # close this host boundary: ! 844: # ! 845: echo "" ! 846: echo " }" ! 847: if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then ! 848: echo "" ! 849: echo "#endif /* TME_HAVE_INT${host_boundary}_T */" ! 850: fi ! 851: ! 852: # advance: ! 853: # ! 854: host_boundary=`expr ${host_boundary} / 2` ! 855: done ! 856: ! 857: echo "}" ! 858: done ! 859: ! 860: # permute for the different sizes: ! 861: # ! 862: for size in ${sizes}; do ! 863: ! 864: if test `expr ${size} \>= ${size_ifdef}` = 1; then ! 865: echo "" ! 866: echo "#ifdef TME_HAVE_INT${size}_T" ! 867: fi ! 868: ! 869: # permute for the different types of memory read and write macros. ! 870: # all of these macros work with memory of any alignment, but for ! 871: # best performance they accept the minimum alignment of the memory ! 872: # known at compile time. ! 873: # ! 874: # the "plain" macros are used to read and write memory that is not ! 875: # shared. ! 876: # ! 877: # the "atomic" macros are used to read and write memory that is ! 878: # shared. the total read or write is always atomic. ! 879: # ! 880: # the "bus" macros are used to read and write memory that is ! 881: # shared, with the access split across the given bus boundary into ! 882: # atomic partials. ! 883: # ! 884: for type_user in plain atomic bus; do ! 885: ! 886: # permute over read and write: ! 887: # ! 888: for op in read write; do ! 889: ! 890: # these macros are for the header file, and there are ! 891: # hand-coded macros for 8-bit values: ! 892: # ! 893: if $header; then :; else continue; fi ! 894: if test ${size} = 8; then continue; fi ! 895: ! 896: # characterize this macro: ! 897: # ! 898: type="_${type_user}" ! 899: type_lock=", lock" ! 900: type_part=_atomic ! 901: type_bus_boundary= ! 902: case ${type_user} in ! 903: plain) ! 904: type= ! 905: type_lock= ! 906: type_part= ! 907: ;; ! 908: bus) ! 909: type_bus_boundary=", bus_boundary" ! 910: ;; ! 911: esac ! 912: if test ${op} = read; then ! 913: op_x= ! 914: op_open=" ( \\" ! 915: op_indent0=" " ! 916: op_indent1=${op_indent0} ! 917: op_then="${op_indent1}? \\" ! 918: op_else_if="${op_indent1}: \\" ! 919: op_else=${op_else_if} ! 920: op_indent2="${op_indent1} " ! 921: op_semi= ! 922: op_close=" )" ! 923: else ! 924: op_x=", x" ! 925: op_open=" do { \\@ if \\" ! 926: op_indent0=" " ! 927: op_indent1=${op_indent0} ! 928: op_then=" { \\" ! 929: op_else_if=" } \\@ else if \\" ! 930: op_else=" } \\@ else \\@${op_then}" ! 931: op_indent2=" " ! 932: op_semi=';' ! 933: op_close=" } \\@ } while (/* CONSTCOND */ 0)" ! 934: fi ! 935: ! 936: # start the macro: ! 937: # ! 938: echo "" ! 939: echo "/* the default ${size}-bit memory ${type_user} ${op} macro: */" ! 940: echo "#define tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min${type_bus_boundary}) \\" ! 941: echo "${op_open}" | tr '@' '\n' ! 942: ! 943: # dispatch on the macro type: ! 944: # ! 945: case ${type_user} in ! 946: ! 947: plain) ! 948: echo "${op_indent0}/* if we know at compile time that the memory is aligned \\" ! 949: echo "${op_indent0} enough to ${op} directly, do the single direct ${op}. \\" ! 950: echo "${op_indent0}\\" ! 951: echo "${op_indent0} otherwise, if we know at compile time that the memory \\" ! 952: echo "${op_indent0} is less aligned than the smallest acceptable parts size, \\" ! 953: echo "${op_indent0} test if the memory is aligned enough to ${op} directly, \\" ! 954: echo "${op_indent0} and do the single direct ${op} if it is: */ \\" ! 955: echo "${op_indent0}(__tme_predict_true((_TME_ALIGNOF_INT${size}_T == 1 \\" ! 956: echo "${op_indent0} || (align_min) >= _TME_ALIGNOF_INT${size}_T) \\" ! 957: echo "${op_indent0} || ((align_min) < TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) \\" ! 958: echo "${op_indent0} && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0))) \\" ! 959: echo "${op_then}" ! 960: echo "${op_indent2}_tme_memory_${op}(tme_uint${size}_t, tme_uint${size}_t, mem, 0${op_x})${op_semi} \\" ! 961: ! 962: # loop over the possible part sizes: ! 963: # ! 964: size_part=8 ! 965: while test ${size_part} != ${size}; do ! 966: ! 967: # at this point, we know that the memory is at ! 968: # least aligned to the part size: ! 969: # ! 970: ! 971: # if this is the last possible part size: ! 972: # ! 973: if test `expr ${size_part} \* 2` = ${size}; then ! 974: ! 975: # we will just access all parts of this size: ! 976: # ! 977: echo "${op_else}" | tr '@' '\n' ! 978: ! 979: # otherwise, this is not the last possible part ! 980: # size: ! 981: # ! 982: else ! 983: ! 984: # if we know at compile time that accessing ! 985: # all parts of this size is acceptable over ! 986: # further testing of the address, and the ! 987: # memory is not more aligned than this part ! 988: # size, we will just access all parts of this ! 989: # size: ! 990: # ! 991: echo "${op_else_if}" | tr '@' '\n' ! 992: echo "${op_indent1}((TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) <= sizeof(tme_uint${size_part}_t)) \\" ! 993: echo "${op_indent1} && ((align_min) <= sizeof(tme_uint${size_part}_t))) \\" ! 994: echo "${op_then}" ! 995: fi ! 996: ! 997: # we always emit one set of partial accesses, all ! 998: # of this part size. ! 999: # ! 1000: # then, if this isn't the last possible part size, ! 1001: # we test if the address is aligned only to this ! 1002: # part size. if it is, we emit a second set of partial ! 1003: # accesses, to transfer this part size, some number ! 1004: # of parts of the next part size, and one part of this ! 1005: # part size: ! 1006: # ! 1007: size_now=${size_part} ! 1008: misaligned=false ! 1009: while true; do ! 1010: size_done=0 ! 1011: while test ${size_done} != ${size}; do ! 1012: ! 1013: # emit one partial transfer: ! 1014: # ! 1015: echo -n "${op_indent2}" ! 1016: op_delim=${op_semi} ! 1017: if test ${op} = read; then ! 1018: if test ${size_done} = 0; then echo -n '('; else echo -n ' | '; fi ! 1019: if test `expr ${size_done} + ${size_now}` = ${size}; then op_delim=')'; fi ! 1020: fi ! 1021: echo "_tme_memory${type}_${op}(tme_uint${size}_t, tme_uint${size_now}_t, mem, (${size_done} / 8)${op_x})${op_delim} \\" ! 1022: ! 1023: # advance: ! 1024: # ! 1025: size_done=`expr ${size_done} + ${size_now}` ! 1026: size_now=`expr ${size} - ${size_done}` ! 1027: if test `expr ${size_now} \> ${size_part}` = 1; then ! 1028: size_now=${size_part} ! 1029: fi ! 1030: done ! 1031: ! 1032: # if we have already done the misaligned set, ! 1033: # stop now: ! 1034: # ! 1035: if ${misaligned}; then ! 1036: break ! 1037: fi ! 1038: misaligned=true ! 1039: ! 1040: # advance to test and do the misaligned set: ! 1041: # ! 1042: size_now=${size_part} ! 1043: size_part=`expr ${size_part} \* 2` ! 1044: if test ${size_part} = ${size}; then ! 1045: break ! 1046: fi ! 1047: echo "${op_else_if}" | tr '@' '\n' ! 1048: echo "${op_indent1}(_tme_memory_address_test(mem, sizeof(tme_uint${size_now}_t), align_min) != 0) \\" ! 1049: echo "${op_then}" ! 1050: done ! 1051: done ! 1052: ;; ! 1053: ! 1054: atomic) ! 1055: echo "${op_indent0}/* if we aren't locking for all memory accesses, and we can \\" ! 1056: echo "${op_indent0} make direct ${size}-bit accesses, and this memory is aligned \\" ! 1057: echo "${op_indent0} enough to make a single direct atomic access, do the single \\" ! 1058: echo "${op_indent0} direct atomic ${op}: */ \\" ! 1059: echo "${op_indent0}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\" ! 1060: echo "${op_indent0} && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\" ! 1061: echo "${op_indent0} && _tme_memory_address_test(mem, TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) - 1, align_min) == 0)) \\" ! 1062: echo "${op_then}" ! 1063: echo "${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\" ! 1064: if test ${op} = write; then ! 1065: echo "${op_indent2} = (x); \\" ! 1066: fi ! 1067: echo "${op_indent1}/* otherwise, we must do a slow indirect atomic ${op}: */ \\" ! 1068: echo "${op_else}" | tr '@' '\n' ! 1069: echo "${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min)${op_semi} \\" ! 1070: ;; ! 1071: ! 1072: bus) ! 1073: echo "${op_indent0}/* if threads are cooperative, do a plain ${op}: */ \\" ! 1074: echo "${op_indent0}(TME_THREADS_COOPERATIVE) \\" ! 1075: echo "${op_then}" ! 1076: echo -n "${op_indent2}tme_memory_${op}${size}(" ! 1077: # this strips off the tme_shared qualifier: ! 1078: # ! 1079: if test ${op} = read; then ! 1080: echo -n "(_tme_const tme_uint${size}_t *) _tme_audit_type(mem, tme_uint${size}_t *)" ! 1081: else ! 1082: echo -n "(tme_uint${size}_t *) _tme_cast_pointer_shared(tme_uint${size}_t *, tme_uint${size}_t *, mem)" ! 1083: fi ! 1084: echo "${op_x}, align_min)${op_semi} \\" ! 1085: ! 1086: echo "${op_indent1}/* otherwise, if we aren't locking for all memory accesses, the \\" ! 1087: echo "${op_indent1} host supports misaligned ${size}-bit accesses, the host's bus \\" ! 1088: echo "${op_indent1} boundary is greater than or equal to the emulated bus \\" ! 1089: echo "${op_indent1} boundary, and this memory is aligned enough, do a single \\" ! 1090: echo "${op_indent1} direct bus ${op}: */ \\" ! 1091: echo "${op_else_if}" | tr '@' '\n' ! 1092: echo "${op_indent1}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\" ! 1093: echo "${op_indent1} && _TME_ALIGNOF_INT${size}_T < sizeof(tme_uint${size}_t) \\" ! 1094: echo "${op_indent1} && TME_MEMORY_BUS_BOUNDARY >= (bus_boundary) \\" ! 1095: echo "${op_indent1} && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0)) \\" ! 1096: echo "${op_then}" ! 1097: echo "${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\" ! 1098: if test ${op} = write; then ! 1099: echo "${op_indent2} = (x); \\" ! 1100: fi ! 1101: ! 1102: echo "${op_indent1}/* otherwise, if we're locking for all memory accesses, or \\" ! 1103: echo "${op_indent1} if this memory must cross at least one host bus boundary \\" ! 1104: echo "${op_indent1} and the host bus boundary is less than the emulated bus \\" ! 1105: echo "${op_indent1} boundary, do a slow indirect atomic ${op}: */ \\" ! 1106: echo "${op_else_if}" | tr '@' '\n' ! 1107: echo "${op_indent1}(__tme_predict_false(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0 \\" ! 1108: echo "${op_indent1} || (sizeof(tme_uint${size}_t) > TME_MEMORY_BUS_BOUNDARY \\" ! 1109: echo "${op_indent1} && TME_MEMORY_BUS_BOUNDARY < (bus_boundary)))) \\" ! 1110: echo "${op_then}" ! 1111: echo "${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, align_min)${op_semi} \\" ! 1112: ! 1113: echo "${op_indent1}/* otherwise, if the memory is not larger than the emulated \\" ! 1114: echo "${op_indent1} bus boundary, or if size-alignment would mean an atomic \\" ! 1115: echo "${op_indent1} host access and it is size-aligned, do a single atomic \\" ! 1116: echo "${op_indent1} ${op}, which may be direct or slow: */ \\" ! 1117: echo "${op_else_if}" | tr '@' '\n' ! 1118: echo "${op_indent1}(__tme_predict_true((sizeof(tme_uint${size}_t) <= (bus_boundary) \\" ! 1119: echo "${op_indent1} || (TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\" ! 1120: echo "${op_indent1} && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) <= sizeof(tme_uint${size}_t))) \\" ! 1121: echo "${op_indent1} && _tme_memory_address_test(mem, sizeof(tme_uint${size}_t) - 1, align_min) == 0)) \\" ! 1122: echo "${op_then}" ! 1123: echo "${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, sizeof(tme_uint${size}_t))${op_semi} \\" ! 1124: echo "${op_indent1}/* otherwise, we must do a slow bus ${op}: */ \\" ! 1125: echo "${op_else}" | tr '@' '\n' ! 1126: echo "${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min, bus_boundary)${op_semi} \\" ! 1127: ;; ! 1128: ! 1129: esac ! 1130: ! 1131: # close this macro: ! 1132: # ! 1133: echo "${op_close}" | tr '@' '\n' ! 1134: done ! 1135: done ! 1136: ! 1137: echo "" ! 1138: echo "/* the ${size}-bit atomic operations: */" ! 1139: ! 1140: # the atomic operations. NB that cx, read, and write are ! 1141: # deliberately at the end and in that order, to allow all earlier ! 1142: # default implementations to still use any host CPU-specific cx, ! 1143: # read and write macros: ! 1144: # ! 1145: for op in add sub mul div and or xor not neg xchg cx read write; do ! 1146: ! 1147: # dispatch on the operation. NB that we don't need to ! 1148: # generate 8-bit atomic read and write operations: ! 1149: # ! 1150: op_rval="tme_uint${size}_t" ! 1151: op_const= ! 1152: op_proto_operand=", tme_uint${size}_t" ! 1153: op_operand=operand ! 1154: op_from=to ! 1155: op_operator= ! 1156: op_operation= ! 1157: op_indent= ! 1158: case ${op} in ! 1159: read) ! 1160: if test ${size} = 8; then continue; fi ! 1161: op_const="_tme_const " ! 1162: op_from=from ! 1163: op_proto_operand= ! 1164: ;; ! 1165: write) ! 1166: if test ${size} = 8; then continue; fi ! 1167: op_rval=void ! 1168: op_operand=value_written ! 1169: ;; ! 1170: cx) ! 1171: op_proto_operand=", tme_uint${size}_t, tme_uint${size}_t" ! 1172: op_operand=value_written ! 1173: op_indent=" " ! 1174: ;; ! 1175: add) op_operator='+' ;; ! 1176: sub) op_operator='-' ;; ! 1177: mul) op_operator='*' ;; ! 1178: div) op_operator='/' ;; ! 1179: and) op_operator='&' ;; ! 1180: or) op_operator='|' ;; ! 1181: xor) op_operator='^' ;; ! 1182: not) op_operation='~value_read' ; op_proto_operand= ;; ! 1183: neg) op_operation='0 - value_read' ; op_proto_operand= ;; ! 1184: xchg) op_operand=value_written ! 1185: esac ! 1186: if test "x${op_operator}" != x; then ! 1187: op_operation="value_read ${op_operator} ${op_operand}" ! 1188: fi ! 1189: ! 1190: # if we're making the header, just emit a prototype: ! 1191: # ! 1192: if $header; then ! 1193: echo "${op_rval} tme_memory_atomic_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int));" ! 1194: continue ! 1195: fi ! 1196: ! 1197: echo "" ! 1198: echo "/* undefine any macro version of tme_memory_atomic_${op}${size}: */" ! 1199: echo "#undef tme_memory_atomic_${op}${size}" ! 1200: echo "" ! 1201: echo "/* the ${size}-bit atomic ${op} function: */" ! 1202: echo "${op_rval}" ! 1203: echo "tme_memory_atomic_${op}${size}(${op_const}tme_shared tme_uint${size}_t *memory," ! 1204: if test ${op} = cx; then ! 1205: echo " tme_uint${size}_t value_cmp," ! 1206: fi ! 1207: if test "x${op_proto_operand}" != x; then ! 1208: echo " tme_uint${size}_t ${op_operand}," ! 1209: fi ! 1210: echo " tme_rwlock_t *rwlock," ! 1211: echo " unsigned int align_min)" ! 1212: echo "{" ! 1213: if test ${op} != write; then ! 1214: echo " tme_uint${size}_t value_read;" ! 1215: fi ! 1216: if test "x${op_operation}" != x; then ! 1217: echo " tme_uint${size}_t value_written;" ! 1218: fi ! 1219: if test ${op} = read || test ${op} = write || test ${op} = cx; then :; else ! 1220: echo " tme_uint${size}_t value_read_verify;" ! 1221: fi ! 1222: echo "" ! 1223: echo " /* if we can't make direct accesses at all, all atomic" ! 1224: echo " accesses must be done under lock. (when threads are" ! 1225: echo " cooperative the actual locking isn't needed): */" ! 1226: echo " if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {" ! 1227: echo " if (!TME_THREADS_COOPERATIVE) {" ! 1228: if test ${op} = read; then ! 1229: echo " tme_rwlock_rdlock(rwlock);" ! 1230: else ! 1231: echo " tme_rwlock_wrlock(rwlock);" ! 1232: fi ! 1233: echo " }" ! 1234: if test ${op} != write; then ! 1235: echo " value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);" ! 1236: fi ! 1237: if test ${op} = cx; then ! 1238: echo " if (value_read == value_cmp) {" ! 1239: fi ! 1240: if test "x${op_operation}" != x; then ! 1241: echo " value_written = ${op_operation};" ! 1242: fi ! 1243: if test ${op} != read; then ! 1244: echo "${op_indent} tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);" ! 1245: fi ! 1246: if test "x${op_indent}" != x; then ! 1247: echo " }" ! 1248: fi ! 1249: echo " if (!TME_THREADS_COOPERATIVE) {" ! 1250: echo " tme_rwlock_unlock(rwlock);" ! 1251: echo " }" ! 1252: echo " }" ! 1253: echo "" ! 1254: echo " /* otherwise, threads are not cooperative and this host CPU" ! 1255: echo " can make atomic accesses to at least the most common memory" ! 1256: echo " size." ! 1257: echo "" ! 1258: echo " in that case, the only reason this function should get" ! 1259: echo " called is if the host CPU can't do an atomic ${size}-bit" ! 1260: echo " ${op} at all, or if it can't do it at this alignment." ! 1261: if test ${op} = read || test ${op} = write || test ${op} = cx; then ! 1262: echo "" ! 1263: echo " we assume that these problematic atomic ${op}s are rare," ! 1264: echo " and to emulate them we simply stop all other threads while" ! 1265: echo " doing the ${op}: */" ! 1266: echo " else {" ! 1267: echo " tme_thread_suspend_others();" ! 1268: if test ${op} != write; then ! 1269: echo " value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);" ! 1270: fi ! 1271: if test ${op} = cx; then ! 1272: echo " if (value_read == value_cmp) {" ! 1273: fi ! 1274: if test ${op} != read; then ! 1275: echo "${op_indent} tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);" ! 1276: fi ! 1277: if test "x${op_indent}" != x; then ! 1278: echo " }" ! 1279: fi ! 1280: echo " tme_thread_resume_others();" ! 1281: echo " }" ! 1282: else ! 1283: echo "" ! 1284: echo " we emulate the atomic ${size}-bit ${op} with a compare-and-exchange: */" ! 1285: echo " else {" ! 1286: echo "" ! 1287: echo " /* do an atomic read of the memory: */" ! 1288: echo " value_read = tme_memory_atomic_read${size}(memory, rwlock, align_min);" ! 1289: echo "" ! 1290: echo " /* spin the ${op} in a compare-and-exchange loop: */" ! 1291: echo " for (;;) {" ! 1292: if test "x${op_operation}" != x; then ! 1293: echo "" ! 1294: echo " /* make the value to write: */" ! 1295: echo " value_written = ${op_operation};" ! 1296: fi ! 1297: echo "" ! 1298: echo " /* try the compare-and-exchange: */" ! 1299: echo " value_read_verify = tme_memory_atomic_cx${size}(memory, value_read, value_written, rwlock, align_min);" ! 1300: echo "" ! 1301: echo " /* if the compare-and-exchange failed: */" ! 1302: echo " if (__tme_predict_false(value_read_verify != value_read)) {" ! 1303: echo "" ! 1304: echo " /* loop with the new value read from the memory: */" ! 1305: echo " value_read = value_read_verify;" ! 1306: echo " continue;" ! 1307: echo " }" ! 1308: echo "" ! 1309: echo " /* stop now: */" ! 1310: echo " break;" ! 1311: echo " }" ! 1312: echo " }" ! 1313: fi ! 1314: if test ${op} != write; then ! 1315: echo "" ! 1316: echo " /* return the value read: */" ! 1317: echo " return (value_read);" ! 1318: fi ! 1319: echo "}" ! 1320: done ! 1321: ! 1322: if test `expr ${size} \>= ${size_ifdef}` = 1; then ! 1323: echo "" ! 1324: echo "#endif /* TME_HAVE_INT${size}_T */" ! 1325: fi ! 1326: ! 1327: done ! 1328: ! 1329: # done: ! 1330: # ! 1331: exit 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.