contrib/llvm/tools/lldb/source/Target/Queue.cpp

   1 //===-- Queue.cpp -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/Process.h"
  11 #include "lldb/Target/Queue.h"
  12 #include "lldb/Target/QueueList.h"
  13 #include "lldb/Target/Thread.h"
  14 #include "lldb/Target/SystemRuntime.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 Queue::Queue (ProcessSP process_sp, lldb::queue_id_t queue_id, const char *queue_name) :
  20     m_process_wp (),
  21     m_queue_id (queue_id),
  22     m_queue_name (),
  23     m_running_work_items_count(0),
  24     m_pending_work_items_count(0),
  25     m_pending_items(),
  26     m_dispatch_queue_t_addr(LLDB_INVALID_ADDRESS),
  27     m_kind (eQueueKindUnknown)
  28 {
  29     if (queue_name)
  30         m_queue_name = queue_name;
  31
  32     m_process_wp = process_sp;
  33 }
  34
  35 Queue::~Queue ()
  36 {
  37 }
  38
  39 queue_id_t
  40 Queue::GetID ()
  41 {
  42     return m_queue_id;
  43 }
  44
  45 const char *
  46 Queue::GetName ()
  47 {
  48     const char *result = NULL;
  49     if (m_queue_name.size() > 0)
  50         result = m_queue_name.c_str();
  51     return result;
  52 }
  53
  54 uint32_t
  55 Queue::GetIndexID ()
  56 {
  57     return m_queue_id;
  58 }
  59
  60 std::vector<lldb::ThreadSP>
  61 Queue::GetThreads ()
  62 {
  63     std::vector<ThreadSP> result;
  64     ProcessSP process_sp = m_process_wp.lock();
  65     if (process_sp.get ())
  66     {
  67         for (ThreadSP thread_sp : process_sp->Threads())
  68         {
  69             if (thread_sp->GetQueueID() == m_queue_id)
  70             {
  71                 result.push_back (thread_sp);
  72             }
  73         }
  74     }
  75     return result;
  76 }
  77
  78 void
  79 Queue::SetNumRunningWorkItems (uint32_t count)
  80 {
  81     m_running_work_items_count = count;
  82 }
  83
  84 uint32_t
  85 Queue::GetNumRunningWorkItems () const
  86 {
  87     return m_running_work_items_count;
  88 }
  89
  90
  91 void
  92 Queue::SetNumPendingWorkItems (uint32_t count)
  93 {
  94     m_pending_work_items_count = count;
  95 }
  96
  97 uint32_t
  98 Queue::GetNumPendingWorkItems () const
  99 {
 100     return m_pending_work_items_count;
 101 }
 102
 103 void
 104 Queue::SetLibdispatchQueueAddress (addr_t dispatch_queue_t_addr)
 105 {
 106     m_dispatch_queue_t_addr = dispatch_queue_t_addr;
 107 }
 108
 109 addr_t
 110 Queue::GetLibdispatchQueueAddress () const
 111 {
 112     return m_dispatch_queue_t_addr;
 113 }
 114
 115
 116 const std::vector<lldb::QueueItemSP> &
 117 Queue::GetPendingItems ()
 118 {
 119     if (m_pending_items.size() == 0)
 120     {
 121         ProcessSP process_sp = m_process_wp.lock();
 122         if (process_sp && process_sp->GetSystemRuntime())
 123         {
 124             process_sp->GetSystemRuntime()->PopulatePendingItemsForQueue (this);
 125         }
 126     }
 127     return m_pending_items;
 128 }
 129
 130 lldb::QueueKind
 131 Queue::GetKind ()
 132 {
 133     return m_kind;
 134 }
 135
 136 void
 137 Queue::SetKind (lldb::QueueKind kind)
 138 {
 139     m_kind = kind;
 140 }