Coverage Report

Created: 2022-01-22 13:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Target/Queue.h
Line
Count
Source (jump to first uncovered line)
1
//===-- Queue.h ------------------------------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLDB_TARGET_QUEUE_H
10
#define LLDB_TARGET_QUEUE_H
11
12
#include <string>
13
#include <vector>
14
15
#include "lldb/Target/QueueItem.h"
16
#include "lldb/lldb-enumerations.h"
17
#include "lldb/lldb-forward.h"
18
#include "lldb/lldb-private.h"
19
20
namespace lldb_private {
21
22
// Queue:
23
// This class represents a libdispatch aka Grand Central Dispatch queue in the
24
// process.
25
//
26
// A program using libdispatch will create queues, put work items
27
// (functions, blocks) on the queues.  The system will create / reassign
28
// pthreads to execute the work items for the queues.  A serial queue will be
29
// associated with a single thread (or possibly no thread, if it is not doing
30
// any work).  A concurrent queue may be associated with multiple threads.
31
32
class Queue : public std::enable_shared_from_this<Queue> {
33
public:
34
  Queue(lldb::ProcessSP process_sp, lldb::queue_id_t queue_id,
35
        const char *queue_name);
36
37
  ~Queue();
38
39
  /// Get the QueueID for this Queue
40
  ///
41
  /// A 64-bit ID number that uniquely identifies a queue at this particular
42
  /// stop_id.  Currently the libdispatch serialnum is used for the QueueID;
43
  /// it is a number that starts at 1 for each process and increments with
44
  /// each queue.  A serialnum is not reused for a different queue in the
45
  /// lifetime of that process execution.
46
  ///
47
  /// \return
48
  ///     The QueueID for this Queue.
49
  lldb::queue_id_t GetID();
50
51
  /// Get the name of this Queue
52
  ///
53
  /// \return
54
  ///     The name of the queue, if one is available.
55
  ///     A NULL pointer is returned if none is available.
56
  const char *GetName();
57
58
  /// Get the IndexID for this Queue
59
  ///
60
  /// This is currently the same as GetID().  If it changes in the future,
61
  /// it will be  a small integer value (starting with 1) assigned to
62
  /// each queue that is seen during a Process lifetime.
63
  ///
64
  /// Both the GetID and GetIndexID are being retained for Queues to
65
  /// maintain similar API to the Thread class, and allow for the
66
  /// possibility of GetID changing to a different source in the future.
67
  ///
68
  /// \return
69
  ///     The IndexID for this queue.
70
  uint32_t GetIndexID();
71
72
  /// Return the threads currently associated with this queue
73
  ///
74
  /// Zero, one, or many threads may be executing code for a queue at
75
  /// a given point in time.  This call returns the list of threads
76
  /// that are currently executing work for this queue.
77
  ///
78
  /// \return
79
  ///     The threads currently performing work for this queue
80
  std::vector<lldb::ThreadSP> GetThreads();
81
82
  /// Return the items that are currently enqueued
83
  ///
84
  /// "Enqueued" means that the item has been added to the queue to
85
  /// be done, but has not yet been done.  When the item is going to
86
  /// be processed it is "dequeued".
87
  ///
88
  /// \return
89
  ///     The vector of enqueued items for this queue
90
  const std::vector<lldb::QueueItemSP> &GetPendingItems();
91
92
33
  lldb::ProcessSP GetProcess() const { return m_process_wp.lock(); }
93
94
  /// Get the number of work items that this queue is currently running
95
  ///
96
  /// \return
97
  ///     The number of work items currently executing.  For a serial
98
  ///     queue, this will be 0 or 1.  For a concurrent queue, this
99
  ///     may be any number.
100
  uint32_t GetNumRunningWorkItems() const;
101
102
  /// Get the number of work items enqueued on this queue
103
  ///
104
  /// \return
105
  ///     The number of work items currently enqueued, waiting to
106
  ///     execute.
107
  uint32_t GetNumPendingWorkItems() const;
108
109
  /// Get the dispatch_queue_t structure address for this Queue
110
  ///
111
  /// Get the address in the inferior process' memory of this Queue's
112
  /// dispatch_queue_t structure.
113
  ///
114
  /// \return
115
  ///     The address of the dispatch_queue_t structure, if known.
116
  ///     LLDB_INVALID_ADDRESS will be returned if it is unavailable.
117
  lldb::addr_t GetLibdispatchQueueAddress() const;
118
119
  void SetNumRunningWorkItems(uint32_t count);
120
121
  void SetNumPendingWorkItems(uint32_t count);
122
123
  void SetLibdispatchQueueAddress(lldb::addr_t dispatch_queue_t_addr);
124
125
0
  void PushPendingQueueItem(lldb::QueueItemSP item) {
126
0
    m_pending_items.push_back(item);
127
0
  }
128
129
  /// Return the kind (serial, concurrent) of this queue.
130
  lldb::QueueKind GetKind();
131
132
  void SetKind(lldb::QueueKind kind);
133
134
private:
135
  // For Queue only
136
137
  lldb::ProcessWP m_process_wp;
138
  lldb::queue_id_t m_queue_id;
139
  std::string m_queue_name;
140
  uint32_t m_running_work_items_count;
141
  uint32_t m_pending_work_items_count;
142
  std::vector<lldb::QueueItemSP> m_pending_items;
143
  lldb::addr_t m_dispatch_queue_t_addr; // address of libdispatch
144
                                        // dispatch_queue_t for this Queue
145
  lldb::QueueKind m_kind;
146
147
  Queue(const Queue &) = delete;
148
  const Queue &operator=(const Queue &) = delete;
149
};
150
151
} // namespace lldb_private
152
153
#endif // LLDB_TARGET_QUEUE_H