15 import string

    26     nullrev,

  1522 @command('debugrevlog', commands.debugrevlogopts +

  1523     [('d', 'dump', False, _('dump index data'))],

  1524     _('-c|-m|FILE'),

  1525     optionalrepo=True)

  1526 def debugrevlog(ui, repo, file_=None, **opts):

  1527     """show data and statistics about a revlog"""

  1528     r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)

  1529 

  1530     if opts.get("dump"):

  1531         numrevs = len(r)

  1532         ui.write(("# rev p1rev p2rev start   end deltastart base   p1   p2"

  1533                  " rawsize totalsize compression heads chainlen\n"))

  1534         ts = 0

  1535         heads = set()

  1536 

  1537         for rev in xrange(numrevs):

  1538             dbase = r.deltaparent(rev)

  1539             if dbase == -1:

  1540                 dbase = rev

  1541             cbase = r.chainbase(rev)

  1542             clen = r.chainlen(rev)

  1543             p1, p2 = r.parentrevs(rev)

  1544             rs = r.rawsize(rev)

  1545             ts = ts + rs

  1546             heads -= set(r.parentrevs(rev))

  1547             heads.add(rev)

  1548             try:

  1549                 compression = ts / r.end(rev)

  1550             except ZeroDivisionError:

  1551                 compression = 0

  1552             ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "

  1553                      "%11d %5d %8d\n" %

  1554                      (rev, p1, p2, r.start(rev), r.end(rev),

  1555                       r.start(dbase), r.start(cbase),

  1556                       r.start(p1), r.start(p2),

  1557                       rs, ts, compression, len(heads), clen))

  1558         return 0

  1559 

  1560     v = r.version

  1561     format = v & 0xFFFF

  1562     flags = []

  1563     gdelta = False

  1564     if v & revlog.REVLOGNGINLINEDATA:

  1565         flags.append('inline')

  1566     if v & revlog.REVLOGGENERALDELTA:

  1567         gdelta = True

  1568         flags.append('generaldelta')

  1569     if not flags:

  1570         flags = ['(none)']

  1571 

  1572     nummerges = 0

  1573     numfull = 0

  1574     numprev = 0

  1575     nump1 = 0

  1576     nump2 = 0

  1577     numother = 0

  1578     nump1prev = 0

  1579     nump2prev = 0

  1580     chainlengths = []

  1581 

  1582     datasize = [None, 0, 0]

  1583     fullsize = [None, 0, 0]

  1584     deltasize = [None, 0, 0]

  1585     chunktypecounts = {}

  1586     chunktypesizes = {}

  1587 

  1588     def addsize(size, l):

  1589         if l[0] is None or size < l[0]:

  1590             l[0] = size

  1591         if size > l[1]:

  1592             l[1] = size

  1593         l[2] += size

  1594 

  1595     numrevs = len(r)

  1596     for rev in xrange(numrevs):

  1597         p1, p2 = r.parentrevs(rev)

  1598         delta = r.deltaparent(rev)

  1599         if format > 0:

  1600             addsize(r.rawsize(rev), datasize)

  1601         if p2 != nullrev:

  1602             nummerges += 1

  1603         size = r.length(rev)

  1604         if delta == nullrev:

  1605             chainlengths.append(0)

  1606             numfull += 1

  1607             addsize(size, fullsize)

  1608         else:

  1609             chainlengths.append(chainlengths[delta] + 1)

  1610             addsize(size, deltasize)

  1611             if delta == rev - 1:

  1612                 numprev += 1

  1613                 if delta == p1:

  1614                     nump1prev += 1

  1615                 elif delta == p2:

  1616                     nump2prev += 1

  1617             elif delta == p1:

  1618                 nump1 += 1

  1619             elif delta == p2:

  1620                 nump2 += 1

  1621             elif delta != nullrev:

  1622                 numother += 1

  1623 

  1624         # Obtain data on the raw chunks in the revlog.

  1625         chunk = r._chunkraw(rev, rev)[1]

  1626         if chunk:

  1627             chunktype = chunk[0]

  1628         else:

  1629             chunktype = 'empty'

  1630 

  1631         if chunktype not in chunktypecounts:

  1632             chunktypecounts[chunktype] = 0

  1633             chunktypesizes[chunktype] = 0

  1634 

  1635         chunktypecounts[chunktype] += 1

  1636         chunktypesizes[chunktype] += size

  1637 

  1638     # Adjust size min value for empty cases

  1639     for size in (datasize, fullsize, deltasize):

  1640         if size[0] is None:

  1641             size[0] = 0

  1642 

  1643     numdeltas = numrevs - numfull

  1644     numoprev = numprev - nump1prev - nump2prev

  1645     totalrawsize = datasize[2]

  1646     datasize[2] /= numrevs

  1647     fulltotal = fullsize[2]

  1648     fullsize[2] /= numfull

  1649     deltatotal = deltasize[2]

  1650     if numrevs - numfull > 0:

  1651         deltasize[2] /= numrevs - numfull

  1652     totalsize = fulltotal + deltatotal

  1653     avgchainlen = sum(chainlengths) / numrevs

  1654     maxchainlen = max(chainlengths)

  1655     compratio = 1

  1656     if totalsize:

  1657         compratio = totalrawsize / totalsize

  1658 

  1659     basedfmtstr = '%%%dd\n'

  1660     basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'

  1661 

  1662     def dfmtstr(max):

  1663         return basedfmtstr % len(str(max))

  1664     def pcfmtstr(max, padding=0):

  1665         return basepcfmtstr % (len(str(max)), ' ' * padding)

  1666 

  1667     def pcfmt(value, total):

  1668         if total:

  1669             return (value, 100 * float(value) / total)

  1670         else:

  1671             return value, 100.0

  1672 

  1673     ui.write(('format : %d\n') % format)

  1674     ui.write(('flags  : %s\n') % ', '.join(flags))

  1675 

  1676     ui.write('\n')

  1677     fmt = pcfmtstr(totalsize)

  1678     fmt2 = dfmtstr(totalsize)

  1679     ui.write(('revisions     : ') + fmt2 % numrevs)

  1680     ui.write(('    merges    : ') + fmt % pcfmt(nummerges, numrevs))

  1681     ui.write(('    normal    : ') + fmt % pcfmt(numrevs - nummerges, numrevs))

  1682     ui.write(('revisions     : ') + fmt2 % numrevs)

  1683     ui.write(('    full      : ') + fmt % pcfmt(numfull, numrevs))

  1684     ui.write(('    deltas    : ') + fmt % pcfmt(numdeltas, numrevs))

  1685     ui.write(('revision size : ') + fmt2 % totalsize)

  1686     ui.write(('    full      : ') + fmt % pcfmt(fulltotal, totalsize))

  1687     ui.write(('    deltas    : ') + fmt % pcfmt(deltatotal, totalsize))

  1688 

  1689     def fmtchunktype(chunktype):

  1690         if chunktype == 'empty':

  1691             return '    %s     : ' % chunktype

  1692         elif chunktype in string.ascii_letters:

  1693             return '    0x%s (%s)  : ' % (hex(chunktype), chunktype)

  1694         else:

  1695             return '    0x%s      : ' % hex(chunktype)

  1696 

  1697     ui.write('\n')

  1698     ui.write(('chunks        : ') + fmt2 % numrevs)

  1699     for chunktype in sorted(chunktypecounts):

  1700         ui.write(fmtchunktype(chunktype))

  1701         ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))

  1702     ui.write(('chunks size   : ') + fmt2 % totalsize)

  1703     for chunktype in sorted(chunktypecounts):

  1704         ui.write(fmtchunktype(chunktype))

  1705         ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))

  1706 

  1707     ui.write('\n')

  1708     fmt = dfmtstr(max(avgchainlen, compratio))

  1709     ui.write(('avg chain length  : ') + fmt % avgchainlen)

  1710     ui.write(('max chain length  : ') + fmt % maxchainlen)

  1711     ui.write(('compression ratio : ') + fmt % compratio)

  1712 

  1713     if format > 0:

  1714         ui.write('\n')

  1715         ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')

  1716                  % tuple(datasize))

  1717     ui.write(('full revision size (min/max/avg)     : %d / %d / %d\n')

  1718              % tuple(fullsize))

  1719     ui.write(('delta size (min/max/avg)             : %d / %d / %d\n')

  1720              % tuple(deltasize))

  1721 

  1722     if numdeltas > 0:

  1723         ui.write('\n')

  1724         fmt = pcfmtstr(numdeltas)

  1725         fmt2 = pcfmtstr(numdeltas, 4)

  1726         ui.write(('deltas against prev  : ') + fmt % pcfmt(numprev, numdeltas))

  1727         if numprev > 0:

  1728             ui.write(('    where prev = p1  : ') + fmt2 % pcfmt(nump1prev,

  1729                                                               numprev))

  1730             ui.write(('    where prev = p2  : ') + fmt2 % pcfmt(nump2prev,

  1731                                                               numprev))

  1732             ui.write(('    other            : ') + fmt2 % pcfmt(numoprev,

  1733                                                               numprev))

  1734         if gdelta:

  1735             ui.write(('deltas against p1    : ')

  1736                      + fmt % pcfmt(nump1, numdeltas))

  1737             ui.write(('deltas against p2    : ')

  1738                      + fmt % pcfmt(nump2, numdeltas))

  1739             ui.write(('deltas against other : ') + fmt % pcfmt(numother,

  1740                                                              numdeltas))

  1741