aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Target/Queue.h
blob: 514481fe8c9d83e456d01ca504ff4bcc7f3158c3 (plain) (blame)
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
//===-- Queue.h ------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_Queue_h_
#define liblldb_Queue_h_

#include <vector>
#include <string>

#include "lldb/lldb-forward.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private.h"
#include "lldb/Target/QueueItem.h"


namespace lldb_private {

//------------------------------------------------------------------
// Queue:
// This class represents a libdispatch aka Grand Central Dispatch
// queue in the process.  
//
// A program using libdispatch will create queues, put work items
// (functions, blocks) on the queues.  The system will create /
// reassign pthreads to execute the work items for the queues.  A
// serial queue will be associated with a single thread (or possibly
// no thread, if it is not doing any work).  A concurrent queue may
// be associated with multiple threads.
//------------------------------------------------------------------


class Queue :
    public std::enable_shared_from_this<Queue>
{
public:

    Queue (lldb::ProcessSP process_sp, lldb::queue_id_t queue_id, const char *queue_name);

    ~Queue ();

    //------------------------------------------------------------------
    /// Get the QueueID for this Queue
    ///
    /// A 64-bit ID number that uniquely identifies a queue at this particular
    /// stop_id.  Currently the libdispatch serialnum is used for the QueueID;
    /// it is a number that starts at 1 for each process and increments with 
    /// each queue.  A serialnum is not reused for a different queue in the
    /// lifetime of that process execution.
    ///
    /// @return
    ///     The QueueID for this Queue.
    //------------------------------------------------------------------
    lldb::queue_id_t
    GetID ();

    //------------------------------------------------------------------
    /// Get the name of this Queue
    ///
    /// @return
    ///     The name of the queue, if one is available.  
    ///     A NULL pointer is returned if none is available.
    //------------------------------------------------------------------
    const char *
    GetName ();

    //------------------------------------------------------------------
    /// Get the IndexID for this Queue
    ///
    /// This is currently the same as GetID().  If it changes in the future,
    /// it will be  a small integer value (starting with 1) assigned to
    /// each queue that is seen during a Process lifetime.  
    /// 
    /// Both the GetID and GetIndexID are being retained for Queues to
    /// maintain similar API to the Thread class, and allow for the 
    /// possibility of GetID changing to a different source in the future.
    ///
    /// @return
    ///     The IndexID for this queue.
    //------------------------------------------------------------------
    uint32_t
    GetIndexID ();

    //------------------------------------------------------------------
    /// Return the threads currently associated with this queue
    ///
    /// Zero, one, or many threads may be executing code for a queue at
    /// a given point in time.  This call returns the list of threads
    /// that are currently executing work for this queue.
    ///
    /// @return
    ///     The threads currently performing work for this queue
    //------------------------------------------------------------------
    std::vector<lldb::ThreadSP>
    GetThreads ();

    //------------------------------------------------------------------
    /// Return the items that are currently enqueued
    ///
    /// "Enqueued" means that the item has been added to the queue to
    /// be done, but has not yet been done.  When the item is going to
    /// be processed it is "dequeued".
    ///
    /// @return
    ///     The vector of enqueued items for this queue
    //------------------------------------------------------------------
    const std::vector<lldb::QueueItemSP> &
    GetPendingItems();

    lldb::ProcessSP
    GetProcess() const
    {
        return m_process_wp.lock(); 
    }

    //------------------------------------------------------------------
    /// Get the number of work items that this queue is currently running
    ///
    /// @return
    ///     The number of work items currently executing.  For a serial 
    ///     queue, this will be 0 or 1.  For a concurrent queue, this 
    ///     may be any number.
    //------------------------------------------------------------------
    uint32_t
    GetNumRunningWorkItems () const;

    //------------------------------------------------------------------
    /// Get the number of work items enqueued on this queue
    ///
    /// @return
    ///     The number of work items currently enqueued, waiting to
    ///     execute.
    //------------------------------------------------------------------
    uint32_t
    GetNumPendingWorkItems () const;

    //------------------------------------------------------------------
    /// Get the dispatch_queue_t structure address for this Queue
    ///
    /// Get the address in the inferior process' memory of this Queue's
    /// dispatch_queue_t structure.
    ///
    /// @return
    ///     The address of the dispatch_queue_t structure, if known.
    ///     LLDB_INVALID_ADDRESS will be returned if it is unavailable.
    //------------------------------------------------------------------
    lldb::addr_t
    GetLibdispatchQueueAddress () const;


    void
    SetNumRunningWorkItems (uint32_t count);

    void
    SetNumPendingWorkItems (uint32_t count);

    void
    SetLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t_addr);

    void
    PushPendingQueueItem (lldb::QueueItemSP item)
    {
        m_pending_items.push_back (item);
    }

    //------------------------------------------------------------------
    /// Return the kind (serial, concurrent) of this queue
    ///
    /// @return
    //      Whether this is a serial or a concurrent queue
    //------------------------------------------------------------------
    lldb::QueueKind
    GetKind ();

    void
    SetKind (lldb::QueueKind kind);

private:
    //------------------------------------------------------------------
    // For Queue only
    //------------------------------------------------------------------

    lldb::ProcessWP                 m_process_wp;
    lldb::queue_id_t                m_queue_id;
    std::string                     m_queue_name;
    uint32_t                        m_running_work_items_count;
    uint32_t                        m_pending_work_items_count;
    std::vector<lldb::QueueItemSP>  m_pending_items;
    lldb::addr_t                    m_dispatch_queue_t_addr;  // address of libdispatch dispatch_queue_t for this Queue
    lldb::QueueKind                 m_kind;

    DISALLOW_COPY_AND_ASSIGN (Queue);
};

} // namespace lldb_private

#endif  // liblldb_Queue_h_