source/Target/Queue.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//===-- Queue.cpp -----------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/Process.h"
#include "lldb/Target/Queue.h"
#include "lldb/Target/QueueList.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/SystemRuntime.h"

using namespace lldb;
using namespace lldb_private;

Queue::Queue (ProcessSP process_sp, lldb::queue_id_t queue_id, const char *queue_name) :
    m_process_wp (),
    m_queue_id (queue_id),
    m_queue_name (),
    m_running_work_items_count(0),
    m_pending_work_items_count(0),
    m_pending_items(),
    m_dispatch_queue_t_addr(LLDB_INVALID_ADDRESS),
    m_kind (eQueueKindUnknown)
{
    if (queue_name)
        m_queue_name = queue_name;

    m_process_wp = process_sp;
}

Queue::~Queue() = default;

queue_id_t
Queue::GetID ()
{
    return m_queue_id;
}

const char *
Queue::GetName ()
{
    return (m_queue_name.empty() ? nullptr : m_queue_name.c_str());
}

uint32_t
Queue::GetIndexID ()
{
    return m_queue_id;
}

std::vector<lldb::ThreadSP>
Queue::GetThreads ()
{
    std::vector<ThreadSP> result;
    ProcessSP process_sp = m_process_wp.lock();
    if (process_sp)
    {
        for (ThreadSP thread_sp : process_sp->Threads())
        {
            if (thread_sp->GetQueueID() == m_queue_id)
            {
                result.push_back (thread_sp);
            }
        }
    }
    return result;
}

void
Queue::SetNumRunningWorkItems (uint32_t count)
{
    m_running_work_items_count = count;
}

uint32_t
Queue::GetNumRunningWorkItems () const
{
    return m_running_work_items_count;
}

void
Queue::SetNumPendingWorkItems (uint32_t count)
{
    m_pending_work_items_count = count;
}

uint32_t
Queue::GetNumPendingWorkItems () const
{
    return m_pending_work_items_count;
}

void
Queue::SetLibdispatchQueueAddress (addr_t dispatch_queue_t_addr)
{
    m_dispatch_queue_t_addr = dispatch_queue_t_addr;
}

addr_t
Queue::GetLibdispatchQueueAddress () const
{
    return m_dispatch_queue_t_addr;
}

const std::vector<lldb::QueueItemSP> &
Queue::GetPendingItems ()
{
    if (m_pending_items.empty())
    {
        ProcessSP process_sp = m_process_wp.lock();
        if (process_sp && process_sp->GetSystemRuntime())
        {
            process_sp->GetSystemRuntime()->PopulatePendingItemsForQueue (this);
        }
    }
    return m_pending_items;
}

lldb::QueueKind
Queue::GetKind ()
{
    return m_kind;
}

void
Queue::SetKind (lldb::QueueKind kind)
{
    m_kind = kind;
}