Python namedtuple 예제들

예제 #1

파일: sched_task_runnable_ratio.py 프로젝트: liuliweibeijing/saber

#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_task_runnable_ratio'

__all__ = [TRACEPOINT]

SchedTaskRunnableRatioBase = namedtuple(TRACEPOINT, ['comm', 'pid', 'ratio'])


class SchedTaskRunnableRatio(SchedTaskRunnableRatioBase):
    __slots__ = ()

    def __new__(cls, comm, pid, ratio):
        pid = int(pid)
        ratio = float(ratio) / 1023.

        return super(cls, SchedTaskRunnableRatio).__new__(
            cls,
            comm=comm,
            pid=pid,
            ratio=ratio,
        )

예제 #2

#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_task_usage_ratio'

__all__ = [TRACEPOINT]

SchedTaskUsageRatioBase = namedtuple(TRACEPOINT, ['comm', 'pid', 'ratio'])


class SchedTaskUsageRatio(SchedTaskUsageRatioBase):
    """
    Tracked task cpu usage ratio [0..1023].
    """
    __slots__ = ()

    def __new__(cls, comm, pid, ratio):
        pid = int(pid)
        ratio = float(self.ratio) / 1023.0

        return super(cls, SchedTaskUsageRatio).__new__(
            cls,
            comm=comm,

예제 #3

파일: sched_boost_cpu.py 프로젝트: chenleichl/ftrace

from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_boost_cpu'

__all__ = [TRACEPOINT]

SchedBoostCpuBase = namedtuple(TRACEPOINT,
    [
    'cpu'
    'util',
    'margin'
    ]
)

class SchedBoostCpu(SchedBoostCpuBase):
    __slots__ = ()
    def __new__(cls, cpu, util, margin):
            cpu = int(cpu)
            util = int(util)
            margin = int(margin)

            return super(cls, SchedBoostCpu).__new__(
                cls,
                cpu=cpu,
                util=util,

예제 #4

파일: sched_rq_nr_running.py 프로젝트: liuliweibeijing/saber

#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_rq_nr_running'

__all__ = [TRACEPOINT]

SchedRqNrRunningBase = namedtuple(TRACEPOINT,
                                  ['cpu', 'nr_running', 'nr_iowait'])


class SchedRqNrRunning(SchedRqNrRunningBase):
    __slots__ = ()

    def __new__(cls, cpu, nr_running, nr_iowait):
        cpu = int(cpu)
        nr_running = int(nr_running)
        nr_iowait = int(nr_iowait)

        return super(cls, SchedRqNrRunning).__new__(
            cls,
            cpu=cpu,
            nr_running=nr_running,
            nr_iowait=nr_iowait,

예제 #5

파일: sched_load_avg_task.py 프로젝트: liuliweibeijing/saber

except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_load_avg_task'


__all__ = [TRACEPOINT]


SchedLoadAvgTaskBase = namedtuple(TRACEPOINT,
    [
    'pid',
    'comm',
    'cpu',
    'load_avg',
    'util_avg',
    'load_sum',
    'util_sum',
    'period_contrib',
    ]
)


class SchedLoadAvgTask(SchedLoadAvgTaskBase):
    __slots__ = ()
    def __new__(cls, pid, comm, load_avg,
                util_avg, load_sum, util_sum, period_contrib):
            pid = int(pid)
            load_avg = int(load_avg)
            util_avg = int(util_avg)
            load_sum = int(load_sum)

예제 #6

#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_task_load_contrib'

__all__ = [TRACEPOINT]

SchedTaskLoadContribBase = namedtuple(TRACEPOINT,
                                      ['comm', 'pid', 'load_contrib'])


class SchedTaskLoadContrib(SchedTaskLoadContribBase):
    __slots__ = ()

    def __new__(cls, comm, pid, load_contrib):
        pid = int(pid)
        load_contrib = float(load_contrib) / 1023.

        return super(cls, SchedTaskLoadContrib).__new__(
            cls,
            comm=comm,
            pid=pid,
            load_contrib=load_contrib,
        )

예제 #7

# Authors:
#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_boost_cpu'

__all__ = [TRACEPOINT]

SchedBoostCpuBase = namedtuple(TRACEPOINT, ['cpu' 'util', 'margin'])


class SchedBoostCpu(SchedBoostCpuBase):
    __slots__ = ()

    def __new__(cls, cpu, util, margin):
        cpu = int(cpu)
        util = int(util)
        margin = int(margin)

        return super(cls, SchedBoostCpu).__new__(
            cls,
            cpu=cpu,
            util=util,
            margin=margin,

예제 #8

파일: cpufreq_sched_request_opp.py 프로젝트: liuliweibeijing/saber

#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'cpufreq_sched_request_opp'

__all__ = [TRACEPOINT]

CpufreqSchedRequestOppBase = namedtuple(
    TRACEPOINT, ['cpu'
                 'capacity', 'freq_new', 'requested_freq'])


class CpufreqSchedRequestOpp(CpufreqSchedRequestOppBase):
    __slots__ = ()

    def __new__(cls, cpu, capacity, freq_new, requested_freq):
        cpu = int(cpu)
        capacity = int(capacity)
        freq_new = int(freq_new)
        requested_freq = int(requested_freq)

        return super(cls, CpufreqSchedRequestOpp).__new__(
            cls,
            cpu=cpu,

예제 #9

파일: sched_task_usage_ratio.py 프로젝트: chenleichl/ftrace

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_task_usage_ratio'


__all__ = [TRACEPOINT]


SchedTaskUsageRatioBase = namedtuple(TRACEPOINT,
    [
    'comm',
    'pid',
    'ratio'
    ]
)


class SchedTaskUsageRatio(SchedTaskUsageRatioBase):
    """
    Tracked task cpu usage ratio [0..1023].
    """
    __slots__ = ()
    def __new__(cls, comm, pid, ratio):
            pid = int(pid)
            ratio = float(self.ratio)/1023.0

            return super(cls, SchedTaskUsageRatio).__new__(

예제 #10

from .register import register_parser
from ftrace.sched_hmp import HMPMigrateMapping
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_hmp_migrate'

__all__ = [TRACEPOINT]

SchedHMPMigrateBase = namedtuple(TRACEPOINT,
    [
    'comm', # Task name
    'pid', # Process pid
    'dest', # Dest. cpu
    'force'
    ]
)

class SchedHMPMigrate(SchedHMPMigrateBase):
    __slots__ = ()
    def __new__(cls, comm, pid, dest, force):
            pid = int(pid)
            dest = int(dest)
            force = force

            return super(cls, SchedHMPMigrate).__new__(
                cls,
                comm=comm,
                pid=pid,

예제 #11

파일: sched_rq_runnable_ratio.py 프로젝트: liuliweibeijing/saber

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_rq_runnable_ratio'


__all__ = [TRACEPOINT]


SchedRQRunnableRatioBase = namedtuple(TRACEPOINT,
    [
    'cpu',
    'ratio'
    ]
)


class SchedRQRunnableRatio(SchedRQRunnableRatioBase):
    """
    Tracked rq runnable ratio [0..1023].
    """
    __slots__ = ()
    def __new__(cls, cpu, ratio):
            cpu = int(cpu)
            ratio = float(self.ratio)/1023.0

            return super(cls, SchedRQRunnableRatio).__new__(
                cls,

예제 #12

파일: sched_rq_nr_running.py 프로젝트: chenleichl/ftrace

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_rq_nr_running'


__all__ = [TRACEPOINT]


SchedRqNrRunningBase = namedtuple(TRACEPOINT,
    [
    'cpu',
    'nr_running',
    'nr_iowait'
    ]
)


class SchedRqNrRunning(SchedRqNrRunningBase):
    __slots__ = ()
    def __new__(cls, cpu, nr_running, nr_iowait):
            cpu = int(cpu)
            nr_running = int(nr_running)
            nr_iowait = int(nr_iowait)

            return super(cls, SchedRqNrRunning).__new__(
                cls,
                cpu=cpu,

예제 #13

파일: sched_load_avg_cpu.py 프로젝트: chenleichl/ftrace

from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_load_avg_cpu'

__all__ = [TRACEPOINT]

SchedLoadAvgCpuBase = namedtuple(TRACEPOINT,
    [
    'cpu'
    'load_avg',
    'util_avg'
    ]
)

class SchedLoadAvgCpu(SchedLoadAvgCpuBase):
    __slots__ = ()
    def __new__(cls, cpu, load_avg, util_avg):
            cpu = int(cpu)
            load_avg = int(load_avg)
            util_avg = int(util_avg)

            return super(cls, SchedLoadAvgCpu).__new__(
                cls,
                cpu=cpu,
                load_avg=load_avg,

예제 #14

파일: cpufreq_sched_update_capacity.py 프로젝트: liuliweibeijing/saber

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'cpufreq_sched_update_capacity'

__all__ = [TRACEPOINT]

CpufreqSchedUpdateCapacityBase = namedtuple(TRACEPOINT,
    [
    'cpu'
    'request',
    'cfs', # fair tasks
    'rt', # real-time
    'dl',
    'total',
    'new_total',
    ]
)

class CpufreqSchedUpdateCapacity(CpufreqSchedUpdateCapacityBase):
    __slots__ = ()
    def __new__(cls, cpu, request, cfs, rt, dl, total, new_total):
            cpu = int(cpu)
            request = bool(request)
            cfs = int(cfs)
            rt = int(rt)
            dl = int(dl)
            total = int(total)

예제 #15

파일: sched_task_runnable_ratio.py 프로젝트: chenleichl/ftrace

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_task_runnable_ratio'


__all__ = [TRACEPOINT]


SchedTaskRunnableRatioBase = namedtuple(TRACEPOINT,
    [
    'comm',
    'pid',
    'ratio'
    ]
)


class SchedTaskRunnableRatio(SchedTaskRunnableRatioBase):
    __slots__ = ()
    def __new__(cls, comm, pid, ratio):
            pid = int(pid)
            ratio = float(ratio)/1023.

            return super(cls, SchedTaskRunnableRatio).__new__(
                cls,
                comm=comm,
                pid=pid,

예제 #16

파일: sched_task_load_contrib.py 프로젝트: chenleichl/ftrace

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_task_load_contrib'


__all__ = [TRACEPOINT]


SchedTaskLoadContribBase = namedtuple(TRACEPOINT,
    [
    'comm',
    'pid',
    'load_contrib'
    ]
)


class SchedTaskLoadContrib(SchedTaskLoadContribBase):
    __slots__ = ()
    def __new__(cls, comm, pid, load_contrib):
            pid = int(pid)
            load_contrib = float(load_contrib)/1023.

            return super(cls, SchedTaskLoadContrib).__new__(
                cls,
                comm=comm,
                pid=pid,

예제 #17

파일: sched_rq_runnable_load.py 프로젝트: liuliweibeijing/saber

try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_rq_runnable_load'


__all__ = [TRACEPOINT]


SchedRQRunnableLoadBase = namedtuple(TRACEPOINT,
    [
    'cpu',
    'load'
    ]
)


class SchedRQRunnableLoad(SchedRQRunnableLoadBase):
    """
    Tracked rq runnable ratio [0..1023].
    """
    __slots__ = ()
    def __new__(cls, cpu, load):
            cpu = int(cpu)
            load = float(load)

            return super(cls, SchedRQRunnableLoad).__new__(
                cls,

예제 #18

파일: cpufreq_sched_request_opp.py 프로젝트: chenleichl/ftrace

from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'cpufreq_sched_request_opp'

__all__ = [TRACEPOINT]

CpufreqSchedRequestOppBase = namedtuple(TRACEPOINT,
    [
    'cpu'
    'capacity',
    'freq_new',
    'requested_freq'
    ]
)

class CpufreqSchedRequestOpp(CpufreqSchedRequestOppBase):
    __slots__ = ()
    def __new__(cls, cpu, capacity, freq_new, requested_freq):
            cpu = int(cpu)
            capacity = int(capacity)
            freq_new = int(freq_new)
            requested_freq = int(requested_freq)

            return super(cls, CpufreqSchedRequestOpp).__new__(
                cls,
                cpu=cpu,

예제 #19

# Authors:
#       Chuk Orakwue <*****@*****.**>

import re
from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple

TRACEPOINT = 'sched_load_avg_cpu'

__all__ = [TRACEPOINT]

SchedLoadAvgCpuBase = namedtuple(TRACEPOINT, ['cpu' 'load_avg', 'util_avg'])


class SchedLoadAvgCpu(SchedLoadAvgCpuBase):
    __slots__ = ()

    def __new__(cls, cpu, load_avg, util_avg):
        cpu = int(cpu)
        load_avg = int(load_avg)
        util_avg = int(util_avg)

        return super(cls, SchedLoadAvgCpu).__new__(
            cls,
            cpu=cpu,
            load_avg=load_avg,
            util_avg=util_avg,

예제 #20

파일: sched_contrib_scale_f.py 프로젝트: liuliweibeijing/saber

from ftrace.common import ParserError
from .register import register_parser
try:
    from ftrace.third_party.cnamedtuple import namedtuple
except ImportError:
    from collections import namedtuple


TRACEPOINT = 'sched_contrib_scale_f'

__all__ = [TRACEPOINT]

SchedContribScaleFBase = namedtuple(TRACEPOINT,
    [
    'cpu'
    'freq_scale_factor',
    'cpu_scale_factor'
    ]
)

class SchedContribScaleF(SchedContribScaleFBase):
    __slots__ = ()
    def __new__(cls, cpu, freq_scale_factor, cpu_scale_factor):
            cpu = int(cpu)
            freq_scale_factor = int(freq_scale_factor)
            cpu_scale_factor = int(cpu_scale_factor)

            return super(cls, SchedContribScaleF).__new__(
                cls,
                cpu=cpu,
                freq_scale_factor=freq_scale_factor,