executor/xeCallQueue.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Test Executor
   3  * ------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Cross-thread function call dispatcher.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "xeCallQueue.hpp"
  25 #include "deInt32.h"
  26 #include "deMemory.h"
  27
  28 using std::vector;
  29
  30 static inline int getNextQueueSize (int curSize, int minNewSize)
  31 {
  32         return de::max(curSize*2, 1<<deLog2Ceil32(minNewSize));
  33 }
  34
  35 namespace xe
  36 {
  37
  38 // CallQueue
  39
  40 CallQueue::CallQueue (void)
  41         : m_callSem             (0)
  42         , m_callQueue   (64)
  43 {
  44 }
  45
  46 CallQueue::~CallQueue (void)
  47 {
  48         // Destroy all calls.
  49         for (vector<Call*>::iterator i = m_calls.begin(); i != m_calls.end(); i++)
  50                 delete *i;
  51 }
  52
  53 void CallQueue::callNext (void)
  54 {
  55         Call* call = DE_NULL;
  56
  57         // Wait for a call.
  58         m_callSem.decrement();
  59
  60         // Acquire call from buffer.
  61         {
  62                 de::ScopedLock lock(m_lock);
  63                 call = m_callQueue.popBack();
  64         }
  65
  66         try
  67         {
  68                 // \note Enqueue lock is not held during call so it is possible to enqueue more work from dispatched call.
  69                 call->getFunction()(CallReader(call));
  70                 call->clear();
  71         }
  72         catch (const std::exception&)
  73         {
  74                 try
  75                 {
  76                         // Try to push call into free calls list.
  77                         de::ScopedLock lock(m_lock);
  78                         m_freeCalls.push_back(call);
  79                 }
  80                 catch (const std::exception&)
  81                 {
  82                         // We can't do anything but ignore this.
  83                 }
  84
  85                 throw;
  86         }
  87
  88         // Push back to free calls list.
  89         {
  90                 de::ScopedLock lock(m_lock);
  91                 m_freeCalls.push_back(call);
  92         }
  93 }
  94
  95 Call* CallQueue::getEmptyCall (void)
  96 {
  97         de::ScopedLock  lock    (m_lock);
  98         Call*                   call    = DE_NULL;
  99
 100         // Try to get from free calls list.
 101         if (!m_freeCalls.empty())
 102         {
 103                 call = m_freeCalls.back();
 104                 m_freeCalls.pop_back();
 105         }
 106
 107         // If no free calls were available, create a new.
 108         if (!call)
 109         {
 110                 m_calls.reserve(m_calls.size()+1);
 111                 call = new Call();
 112                 m_calls.push_back(call);
 113         }
 114
 115         return call;
 116 }
 117
 118 void CallQueue::enqueue (Call* call)
 119 {
 120         de::ScopedLock lock(m_lock);
 121
 122         if (m_callQueue.getNumFree() == 0)
 123         {
 124                 // Call queue must be grown.
 125                 m_callQueue.resize(getNextQueueSize(m_callQueue.getSize(), m_callQueue.getSize()+1));
 126         }
 127
 128         m_callQueue.pushFront(call);
 129         m_callSem.increment();
 130 }
 131
 132 void CallQueue::freeCall (Call* call)
 133 {
 134         de::ScopedLock lock(m_lock);
 135         m_freeCalls.push_back(call);
 136 }
 137
 138 // Call
 139
 140 Call::Call (void)
 141         : m_func(DE_NULL)
 142 {
 143 }
 144
 145 Call::~Call (void)
 146 {
 147 }
 148
 149 void Call::clear (void)
 150 {
 151         m_func = DE_NULL;
 152         m_data.clear();
 153 }
 154
 155 // CallReader
 156
 157 CallReader::CallReader (Call* call)
 158         : m_call        (call)
 159         , m_curPos      (0)
 160 {
 161 }
 162
 163 void CallReader::read (deUint8* bytes, int numBytes)
 164 {
 165         DE_ASSERT(m_curPos + numBytes <= m_call->getDataSize());
 166         deMemcpy(bytes, m_call->getData()+m_curPos, numBytes);
 167         m_curPos += numBytes;
 168 }
 169
 170 const deUint8* CallReader::getDataBlock (int numBytes)
 171 {
 172         DE_ASSERT(m_curPos + numBytes <= m_call->getDataSize());
 173
 174         const deUint8* ptr = m_call->getData()+m_curPos;
 175         m_curPos += numBytes;
 176
 177         return ptr;
 178 }
 179
 180 CallReader& operator>> (CallReader& reader, std::string& value)
 181 {
 182         value.clear();
 183         for (;;)
 184         {
 185                 char c;
 186                 reader.read((deUint8*)&c, sizeof(char));
 187                 if (c != 0)
 188                         value.push_back(c);
 189                 else
 190                         break;
 191         }
 192
 193         return reader;
 194 }
 195
 196 // CallWriter
 197
 198 CallWriter::CallWriter (CallQueue* queue, Call::Function function)
 199         : m_queue               (queue)
 200         , m_call                (queue->getEmptyCall())
 201         , m_enqueued    (false)
 202 {
 203         m_call->setFunction(function);
 204 }
 205
 206 CallWriter::~CallWriter (void)
 207 {
 208         if (!m_enqueued)
 209                 m_queue->freeCall(m_call);
 210 }
 211
 212 void CallWriter::write (const deUint8* bytes, int numBytes)
 213 {
 214         DE_ASSERT(!m_enqueued);
 215         int curPos = m_call->getDataSize();
 216         m_call->setDataSize(curPos+numBytes);
 217         deMemcpy(m_call->getData()+curPos, bytes, numBytes);
 218 }
 219
 220 void CallWriter::enqueue (void)
 221 {
 222         DE_ASSERT(!m_enqueued);
 223         m_queue->enqueue(m_call);
 224         m_enqueued = true;
 225 }
 226
 227 CallWriter& operator<< (CallWriter& writer, const char* str)
 228 {
 229         int pos = 0;
 230         for (;;)
 231         {
 232                 writer.write((const deUint8*)str + pos, sizeof(char));
 233                 if (str[pos] == 0)
 234                         break;
 235                 pos += 1;
 236         }
 237
 238         return writer;
 239 }
 240
 241 } // xe