← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/utils/lit/lit/Util.py

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/utils/lit/lit/Util.py
 
1
import os, sys
 
2
 
 
3
def detectCPUs():
 
4
    """
 
5
    Detects the number of CPUs on a system. Cribbed from pp.
 
6
    """
 
7
    # Linux, Unix and MacOS:
 
8
    if hasattr(os, "sysconf"):
 
9
        if os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"):
 
10
            # Linux & Unix:
 
11
            ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
 
12
            if isinstance(ncpus, int) and ncpus > 0:
 
13
                return ncpus
 
14
        else: # OSX:
 
15
            return int(os.popen2("sysctl -n hw.ncpu")[1].read())
 
16
    # Windows:
 
17
    if os.environ.has_key("NUMBER_OF_PROCESSORS"):
 
18
        ncpus = int(os.environ["NUMBER_OF_PROCESSORS"])
 
19
        if ncpus > 0:
 
20
            return ncpus
 
21
    return 1 # Default
 
22
 
 
23
def mkdir_p(path):
 
24
    """mkdir_p(path) - Make the "path" directory, if it does not exist; this
 
25
    will also make directories for any missing parent directories."""
 
26
    import errno
 
27
 
 
28
    if not path or os.path.exists(path):
 
29
        return
 
30
 
 
31
    parent = os.path.dirname(path) 
 
32
    if parent != path:
 
33
        mkdir_p(parent)
 
34
 
 
35
    try:
 
36
        os.mkdir(path)
 
37
    except OSError,e:
 
38
        # Ignore EEXIST, which may occur during a race condition.
 
39
        if e.errno != errno.EEXIST:
 
40
            raise
 
41
 
 
42
def capture(args, env=None):
 
43
    import subprocess
 
44
    """capture(command) - Run the given command (or argv list) in a shell and
 
45
    return the standard output."""
 
46
    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
 
47
                         env=env)
 
48
    out,_ = p.communicate()
 
49
    return out
 
50
 
 
51
def which(command, paths = None):
 
52
    """which(command, [paths]) - Look up the given command in the paths string
 
53
    (or the PATH environment variable, if unspecified)."""
 
54
 
 
55
    if paths is None:
 
56
        paths = os.environ.get('PATH','')
 
57
 
 
58
    # Check for absolute match first.
 
59
    if os.path.exists(command):
 
60
        return command
 
61
 
 
62
    # Would be nice if Python had a lib function for this.
 
63
    if not paths:
 
64
        paths = os.defpath
 
65
 
 
66
    # Get suffixes to search.
 
67
    pathext = os.environ.get('PATHEXT', '').split(os.pathsep)
 
68
 
 
69
    # Search the paths...
 
70
    for path in paths.split(os.pathsep):
 
71
        for ext in pathext:
 
72
            p = os.path.join(path, command + ext)
 
73
            if os.path.exists(p):
 
74
                return p
 
75
 
 
76
    return None
 
77
 
 
78
def printHistogram(items, title = 'Items'):
 
79
    import itertools, math
 
80
 
 
81
    items.sort(key = lambda (_,v): v)
 
82
 
 
83
    maxValue = max([v for _,v in items])
 
84
 
 
85
    # Select first "nice" bar height that produces more than 10 bars.
 
86
    power = int(math.ceil(math.log(maxValue, 10)))
 
87
    for inc in itertools.cycle((5, 2, 2.5, 1)):
 
88
        barH = inc * 10**power
 
89
        N = int(math.ceil(maxValue / barH))
 
90
        if N > 10:
 
91
            break
 
92
        elif inc == 1:
 
93
            power -= 1
 
94
 
 
95
    histo = [set() for i in range(N)]
 
96
    for name,v in items:
 
97
        bin = min(int(N * v/maxValue), N-1)
 
98
        histo[bin].add(name)
 
99
 
 
100
    barW = 40
 
101
    hr = '-' * (barW + 34)
 
102
    print '\nSlowest %s:' % title
 
103
    print hr
 
104
    for name,value in items[-20:]:
 
105
        print '%.2fs: %s' % (value, name)
 
106
    print '\n%s Times:' % title
 
107
    print hr
 
108
    pDigits = int(math.ceil(math.log(maxValue, 10)))
 
109
    pfDigits = max(0, 3-pDigits)
 
110
    if pfDigits:
 
111
        pDigits += pfDigits + 1
 
112
    cDigits = int(math.ceil(math.log(len(items), 10)))
 
113
    print "[%s] :: [%s] :: [%s]" % ('Range'.center((pDigits+1)*2 + 3),
 
114
                                    'Percentage'.center(barW),
 
115
                                    'Count'.center(cDigits*2 + 1))
 
116
    print hr
 
117
    for i,row in enumerate(histo):
 
118
        pct = float(len(row)) / len(items)
 
119
        w = int(barW * pct)
 
120
        print "[%*.*fs,%*.*fs)" % (pDigits, pfDigits, i*barH,
 
121
                                   pDigits, pfDigits, (i+1)*barH),
 
122
        print ":: [%s%s] :: [%*d/%*d]" % ('*'*w, ' '*(barW-w),
 
123
                                          cDigits, len(row),
 
124
                                          cDigits, len(items))
 
125