Ejemplo n.º 1
0
def ReportOpenglDevices(request, selected):
    cursor = connection.cursor()
    cursor.execute('''
        SELECT DISTINCT device_name
        FROM userreport_graphicsdevice
    ''')
    all_devices = set(n for (n, ) in cursor.fetchall())

    all_limits = set()
    all_exts = set()
    devices = {}
    gl_renderers = set()

    reports = GraphicsDevice.objects.filter(device_name__in=selected)
    for report in reports:
        exts = frozenset(e.name for e in report.graphicsextension_set.all())
        all_exts |= exts

        limits = dict(
            (l.name, l.value) for l in report.graphicslimit_set.all())
        all_limits |= set(limits.keys())

        devices.setdefault(
            hashabledict({
                'device': report.device_name,
                'os': report.os
            }), {}).setdefault((hashabledict(limits), exts),
                               set()).add(report.driver)

        gl_renderers.add(report.renderer)

    if len(selected) == 1 and len(devices) == 0:
        raise Http404

    all_limits = sorted(all_limits)
    all_exts = sorted(all_exts)

    distinct_devices = []
    for (renderer, v) in devices.items():
        for (caps, versions) in v.items():
            distinct_devices.append((renderer, sorted(versions), caps))
    distinct_devices.sort(key=lambda x: (x[0]['device'], x))

    return render_to_response(
        'reports/opengl_device.html', {
            'selected': selected,
            'all_limits': all_limits,
            'all_exts': all_exts,
            'all_devices': all_devices,
            'devices': distinct_devices,
            'gl_renderers': gl_renderers,
        })
Ejemplo n.º 2
0
def report_hwdetect_test_data(request):
    reports = UserReport_hwdetect.objects
    reports = reports.filter(data_type='hwdetect', data_version__gte=1)

    data = set()
    for report in reports:
        json = report.data_json_nocache()
        relevant = {
            'os_unix': json['os_unix'],
            'os_linux': json['os_linux'],
            'os_macosx': json['os_macosx'],
            'os_win': json['os_win'],
            'gfx_card': json['gfx_card'],
            'gfx_drv_ver': json['gfx_drv_ver'],
            'gfx_mem': json['gfx_mem'],
            'GL_VENDOR': json['GL_VENDOR'],
            'GL_RENDERER': json['GL_RENDERER'],
            'GL_VERSION': json['GL_VERSION'],
            'GL_EXTENSIONS': json['GL_EXTENSIONS'],
        }
        data.add(hashabledict(relevant))

    json = json.dumps(list(data), indent=1, sort_keys=True)
    return HttpResponse('var hwdetectTestData = %s' % json,
                        content_type='text/plain')
Ejemplo n.º 3
0
def ReportOpenglJson(request):
    devices = {}

    reports = GraphicsDevice.objects.all()
    for report in reports:
        exts = frozenset(e.name for e in report.graphicsextension_set.all())
        limits = dict(
            (l.name, l.value) for l in report.graphicslimit_set.all())

        device = (report.vendor, report.renderer, report.os, report.driver)
        devices.setdefault((hashabledict(limits), exts), set()).add(device)

    sorted_devices = devices.items(
    )  #sorted(devices.items(), key=devices.items().get)

    data = []
    for (limits, exts), deviceset in sorted_devices:
        devices = [{
            'vendor': v,
            'renderer': r,
            'os': o,
            'driver': d
        } for (v, r, o, d) in sorted(deviceset)]
        data.append({
            'devices': devices,
            'limits': limits,
            'extensions': sorted(exts)
        })
    json = simplejson.dumps(data, indent=1, sort_keys=True)
    return HttpResponse(json, content_type='text/plain')
Ejemplo n.º 4
0
def ReportOpenglDevices(request, selected):
    cursor = connection.cursor()
    cursor.execute('''
        SELECT DISTINCT device_name
        FROM userreport_graphicsdevice
    ''')
    all_devices = set(n for (n,) in cursor.fetchall())

    all_limits = set()
    all_exts = set()
    devices = {}
    gl_renderers = set()

    reports = GraphicsDevice.objects.filter(device_name__in = selected)
    for report in reports:
        exts = frozenset(e.name for e in report.graphicsextension_set.all())
        all_exts |= exts

        limits = dict((l.name, l.value) for l in report.graphicslimit_set.all())
        all_limits |= set(limits.keys())

        devices.setdefault(hashabledict({'device': report.device_name, 'os': report.os}), {}).setdefault((hashabledict(limits), exts), set()).add(report.driver)

        gl_renderers.add(report.renderer)

    if len(selected) == 1 and len(devices) == 0:
        raise Http404

    all_limits = sorted(all_limits)
    all_exts = sorted(all_exts)

    distinct_devices = []
    for (renderer, v) in devices.items():
        for (caps, versions) in v.items():
            distinct_devices.append((renderer, sorted(versions), caps))
    distinct_devices.sort(key = lambda x: (x[0]['device'], x))

    return render_to_response('reports/opengl_device.html', {
        'selected': selected,
        'all_limits': all_limits,
        'all_exts': all_exts,
        'all_devices': all_devices,
        'devices': distinct_devices,
        'gl_renderers': gl_renderers,
    })
Ejemplo n.º 5
0
def ReportOpenglJson(request):
    devices = {}

    reports = GraphicsDevice.objects.all()
    for report in reports:
        exts = frozenset(e.name for e in report.graphicsextension_set.all())
        limits = dict((l.name, l.value) for l in report.graphicslimit_set.all())

        device = (report.vendor, report.renderer, report.os, report.driver)
        devices.setdefault((hashabledict(limits), exts), set()).add(device)

    sorted_devices = devices.items()  # sorted(devices.items(), key=devices.items().get)

    data = []
    for (limits, exts), deviceset in sorted_devices:
        devices = [
            {'vendor': v, 'renderer': r, 'os': o, 'driver': d}
            for (v, r, o, d) in sorted(deviceset)
        ]
        data.append({'devices': devices, 'limits': limits, 'extensions': sorted(exts)})
    json_string = json.dumps(data, indent=1, sort_keys=True)
    return HttpResponse(json_string, content_type='text/plain')
Ejemplo n.º 6
0
def report_hwdetect_test_data(request):
    reports = UserReport_hwdetect.objects
    reports = reports.filter(data_type='hwdetect', data_version__gte=1)

    data = set()
    for report in reports:
        json = report.data_json_nocache()
        relevant = {
            'os_unix': json['os_unix'],
            'os_linux': json['os_linux'],
            'os_macosx': json['os_macosx'],
            'os_win': json['os_win'],
            'gfx_card': json['gfx_card'],
            'gfx_drv_ver': json['gfx_drv_ver'],
            'gfx_mem': json['gfx_mem'],
            'GL_VENDOR': json['GL_VENDOR'],
            'GL_RENDERER': json['GL_RENDERER'],
            'GL_VERSION': json['GL_VERSION'],
            'GL_EXTENSIONS': json['GL_EXTENSIONS'],
        }
        data.add(hashabledict(relevant))

    json = json.dumps(list(data), indent=1, sort_keys=True)
    return HttpResponse('var hwdetectTestData = %s' % json, content_type='text/plain')
Ejemplo n.º 7
0
def ReportOpenglFeature(request, feature):
    all_values = set()
    usercounts = {}
    values = {}

    cursor = connection.cursor()

    is_extension = False
    if re.search(r'[a-z]', feature):
        is_extension = True

    if is_extension:
        cursor.execute('''
            SELECT vendor, renderer, os, driver, device_name, SUM(usercount),
                (SELECT 1 FROM userreport_graphicsextension e WHERE e.name = %s AND e.device_id = d.id) AS val
            FROM userreport_graphicsdevice d
            GROUP BY vendor, renderer, os, driver, device_name, val
        ''', [feature])

        for vendor, renderer, os, driver, device_name, usercount, val in cursor:
            val = 'true' if val else 'false'
            all_values.add(val)
            usercounts[val] = usercounts.get(val, 0) + usercount
            v = values.setdefault(val, {}).setdefault(hashabledict({
                'vendor': vendor,
                'renderer': renderer,
                'os': os,
                'device': device_name
            }), {'usercount': 0, 'drivers': set()})
            v['usercount'] += usercount
            v['drivers'].add(driver)

    else:
        cursor.execute('''
            SELECT value, vendor, renderer, os, driver, device_name, usercount
            FROM userreport_graphicslimit l
            JOIN userreport_graphicsdevice d
                ON l.device_id = d.id
            WHERE name = %s
        ''', [feature])

        for val, vendor, renderer, os, driver, device_name, usercount in cursor:
            # Convert to int/float if possible, for better sorting
            try: val = int(val)
            except ValueError:
                try: val = float(val)
                except ValueError: pass

            all_values.add(val)
            usercounts[val] = usercounts.get(val, 0) + usercount
            v = values.setdefault(val, {}).setdefault(hashabledict({
                'vendor': vendor,
                'renderer': renderer,
                'os': os,
                'device': device_name
            }), {'usercount': 0, 'drivers': set()})
            v['usercount'] += usercount
            v['drivers'].add(driver)

    if values.keys() == [] or values.keys() == ['false']:
        raise Http404

    num_users = sum(usercounts.values())

    return render_to_response('reports/opengl_feature.html', {
        'feature': feature,
        'all_values': all_values,
        'values': values,
        'is_extension': is_extension,
        'usercounts': usercounts,
        'num_users': num_users,
    })
Ejemplo n.º 8
0
def ReportCpu(request):
    reports = UserReport_hwdetect.objects
    reports = reports.filter(data_type='hwdetect', data_version__gte=4)

    all_users = set()
    cpus = {}

    for report in reports:
        json = report.data_json_nocache()
        if json is None:
            continue

        cpu = {}
        for x in (
                'x86_vendor',
                'x86_model',
                'x86_family',
                'cpu_identifier',
                'cpu_frequency',
                'cpu_numprocs',
                'cpu_numpackages',
                'cpu_coresperpackage',
                'cpu_logicalpercore',
                'cpu_numcaches',
                'cpu_pagesize',
                'cpu_largepagesize',
                'numa_numnodes',
                'numa_factor',
                'numa_interleaved',
        ):
            cpu[x] = json[x]

        cpu['os'] = report.os()

        def fmt_size(s):
            if s % (1024 * 1024) == 0:
                return "%d MB" % (s / (1024 * 1024))
            if s % 1024 == 0:
                return "%d kB" % (s / 1024)
            return "%d B" % s

        def fmt_assoc(w):
            if w == 255:
                return 'fully-assoc'
            else:
                return '%d-way' % w

        def fmt_cache(c, t):
            types = ('?', 'D', 'I ', 'U')
            if c['type'] == 0:
                return "(Unknown %s cache)" % t
            return "L%d %s: %s (%s, shared %dx%s)" % (
                c['level'], types[c['type']], fmt_size(c['totalsize']),
                fmt_assoc(c['associativity']), c['sharedby'],
                ('' if c['linesize'] == 64 else ', %dB line' % c['linesize']))

        def fmt_tlb(c, t):
            types = ('?', 'D', 'I ', 'U')
            if c['type'] == 0:
                return "(Unknown %s TLB)" % t
            return "L%d %s: %d-entry (%s, %s page)" % (
                c['level'], types[c['type']], c['entries'],
                fmt_assoc(c['associativity']), fmt_size(c['pagesize']))

        def fmt_caches(d, i, cb):
            dcaches = d[:]
            icaches = i[:]
            caches = []
            while len(dcaches) or len(icaches):
                if len(dcaches) and len(icaches) and \
                   dcaches[0] == icaches[0] and dcaches[0]['type'] == 3:
                    caches.append(cb(dcaches[0], 'U'))
                    dcaches.pop(0)
                    icaches.pop(0)
                else:
                    if len(dcaches):
                        caches.append(cb(dcaches[0], 'D'))
                        dcaches.pop(0)
                    if len(icaches):
                        caches.append(cb(icaches[0], 'I'))
                        icaches.pop(0)
            return tuple(caches)

        try:
            cpu['caches'] = fmt_caches(json['x86_dcaches'],
                                       json['x86_icaches'], fmt_cache)
            cpu['tlbs'] = fmt_caches(json['x86_tlbs'], json['x86_tlbs'],
                                     fmt_tlb)
        except TypeError:
            continue  # skip on bogus cache data

        caps = set()
        for (n, _, b) in x86.cap_bits:
            if n.endswith('[2]'):
                continue
            if json['x86_caps[%d]' % (b / 32)] & (1 << (b % 32)):
                caps.add(n)
        cpu['caps'] = frozenset(caps)

        all_users.add(report.user_id_hash)
        cpus.setdefault(hashabledict(cpu), set()).add(report.user_id_hash)

    return render_to_response('reports/cpu.html', {
        'cpus': cpus,
        'x86_cap_descs': x86.cap_descs
    },
                              context_instance=RequestContext(request))
Ejemplo n.º 9
0
def ReportCpu(request):
    reports = UserReport_hwdetect.objects
    reports = reports.filter(data_type='hwdetect', data_version__gte=4)

    all_users = set()
    cpus = {}

    for report in reports:
        json = report.data_json_nocache()
        if json is None:
            continue

        cpu = {}
        for x in (
            'x86_vendor', 'x86_model', 'x86_family',
            'cpu_identifier', 'cpu_frequency',
            'cpu_numprocs', 'cpu_numpackages', 'cpu_coresperpackage',
            'cpu_logicalpercore',
            'cpu_numcaches', 'cpu_pagesize', 'cpu_largepagesize',
            'numa_numnodes', 'numa_factor', 'numa_interleaved',
        ):
            cpu[x] = json[x]

        cpu['os'] = report.os()

        def fmt_size(s):
            if s % (1024*1024) == 0:
                return "%d MB" % (s / (1024*1024))
            if s % 1024 == 0:
                return "%d kB" % (s / 1024)
            return "%d B" % s

        def fmt_assoc(w):
            if w == 255:
                return 'fully-assoc'
            else:
                return '%d-way' % w

        def fmt_cache(c, t):
            types = ('?', 'D', 'I ', 'U')
            if c['type'] == 0:
                return "(Unknown %s cache)" % t
            return "L%d %s: %s (%s, shared %dx%s)" % (
                c['level'], types[c['type']], fmt_size(c['totalsize']),
                fmt_assoc(c['associativity']), c['sharedby'],
                ('' if c['linesize'] == 64 else ', %dB line' % c['linesize'])
            )

        def fmt_tlb(c, t):
            types = ('?', 'D', 'I ', 'U')
            if c['type'] == 0:
                return "(Unknown %s TLB)" % t
            return "L%d %s: %d-entry (%s, %s page)" % (
                c['level'], types[c['type']], c['entries'],
                fmt_assoc(c['associativity']), fmt_size(c['pagesize'])
            )

        def fmt_caches(d, i, cb):
            dcaches = d[:]
            icaches = i[:]
            caches = []
            while len(dcaches) or len(icaches):
                if len(dcaches) and len(icaches) and \
                   dcaches[0] == icaches[0] and dcaches[0]['type'] == 3:
                    caches.append(cb(dcaches[0], 'U'))
                    dcaches.pop(0)
                    icaches.pop(0)
                else:
                    if len(dcaches):
                        caches.append(cb(dcaches[0], 'D'))
                        dcaches.pop(0)
                    if len(icaches):
                        caches.append(cb(icaches[0], 'I'))
                        icaches.pop(0)
            return tuple(caches)

        try:
            cpu['caches'] = fmt_caches(json['x86_dcaches'],
                                       json['x86_icaches'], fmt_cache)
            cpu['tlbs'] = fmt_caches(json['x86_tlbs'],
                                     json['x86_tlbs'], fmt_tlb)
        except TypeError:
            continue  # skip on bogus cache data

        caps = set()
        for (n, _, b) in x86.cap_bits:
            if n.endswith('[2]'):
                continue
            if json['x86_caps[%d]' % (b / 32)] & (1 << (b % 32)):
                caps.add(n)
        cpu['caps'] = frozenset(caps)

        all_users.add(report.user_id_hash)
        cpus.setdefault(hashabledict(cpu), set()).add(report.user_id_hash)

    return render_to_response('reports/cpu.html', {'cpus': cpus, 'x86_cap_descs': x86.cap_descs}, context_instance=RequestContext(request))
Ejemplo n.º 10
0
def ReportOpenglFeature(request, feature):
    all_values = set()
    usercounts = {}
    values = {}

    cursor = connection.cursor()

    is_extension = False
    if re.search(r'[a-z]', feature):
        is_extension = True

    if is_extension:
        cursor.execute(
            '''
            SELECT vendor, renderer, os, driver, device_name, SUM(usercount),
                (SELECT 1 FROM userreport_graphicsextension e WHERE e.name = %s AND e.device_id = d.id) AS val
            FROM userreport_graphicsdevice d
            GROUP BY vendor, renderer, os, driver, device_name, val
        ''', [feature])

        for vendor, renderer, os, driver, device_name, usercount, val in cursor:
            val = 'true' if val else 'false'
            all_values.add(val)
            usercounts[val] = usercounts.get(val, 0) + usercount
            v = values.setdefault(val, {}).setdefault(
                hashabledict({
                    'vendor': vendor,
                    'renderer': renderer,
                    'os': os,
                    'device': device_name
                }), {
                    'usercount': 0,
                    'drivers': set()
                })
            v['usercount'] += usercount
            v['drivers'].add(driver)

    else:
        cursor.execute(
            '''
            SELECT value, vendor, renderer, os, driver, device_name, usercount
            FROM userreport_graphicslimit l
            JOIN userreport_graphicsdevice d
                ON l.device_id = d.id
            WHERE name = %s
        ''', [feature])

        for val, vendor, renderer, os, driver, device_name, usercount in cursor:
            # Convert to int/float if possible, for better sorting
            try:
                val = int(val)
            except ValueError:
                try:
                    val = float(val)
                except ValueError:
                    pass

            all_values.add(val)
            usercounts[val] = usercounts.get(val, 0) + usercount
            v = values.setdefault(val, {}).setdefault(
                hashabledict({
                    'vendor': vendor,
                    'renderer': renderer,
                    'os': os,
                    'device': device_name
                }), {
                    'usercount': 0,
                    'drivers': set()
                })
            v['usercount'] += usercount
            v['drivers'].add(driver)

    if values.keys() == [] or values.keys() == ['false']:
        raise Http404

    num_users = sum(usercounts.values())

    return render_to_response(
        'reports/opengl_feature.html', {
            'feature': feature,
            'all_values': all_values,
            'values': values,
            'is_extension': is_extension,
            'usercounts': usercounts,
            'num_users': num_users,
        })