Merge "x11: Call XInitThreads()" into nougat-cts-dev am: cbdbf95222 am: a74d50ffda...
[platform/upstream/VK-GL-CTS.git] / 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_canceled    (false)
42         , m_callSem             (0)
43         , m_callQueue   (64)
44 {
45 }
46
47 CallQueue::~CallQueue (void)
48 {
49         // Destroy all calls.
50         for (vector<Call*>::iterator i = m_calls.begin(); i != m_calls.end(); i++)
51                 delete *i;
52 }
53
54 void CallQueue::cancel (void)
55 {
56         m_canceled = true;
57         m_callSem.increment();
58 }
59
60 void CallQueue::callNext (void)
61 {
62         Call* call = DE_NULL;
63
64         // Wait for a call.
65         m_callSem.decrement();
66
67         if (m_canceled)
68                 return;
69
70         // Acquire call from buffer.
71         {
72                 de::ScopedLock lock(m_lock);
73                 call = m_callQueue.popBack();
74         }
75
76         try
77         {
78                 // \note Enqueue lock is not held during call so it is possible to enqueue more work from dispatched call.
79                 CallReader reader(call);
80
81                 call->getFunction()(reader);
82
83                 // check callee consumed all
84                 DE_ASSERT(reader.isDataConsumed());
85                 call->clear();
86         }
87         catch (const std::exception&)
88         {
89                 try
90                 {
91                         // Try to push call into free calls list.
92                         de::ScopedLock lock(m_lock);
93                         m_freeCalls.push_back(call);
94                 }
95                 catch (const std::exception&)
96                 {
97                         // We can't do anything but ignore this.
98                 }
99
100                 throw;
101         }
102
103         // Push back to free calls list.
104         {
105                 de::ScopedLock lock(m_lock);
106                 m_freeCalls.push_back(call);
107         }
108 }
109
110 Call* CallQueue::getEmptyCall (void)
111 {
112         de::ScopedLock  lock    (m_lock);
113         Call*                   call    = DE_NULL;
114
115         // Try to get from free calls list.
116         if (!m_freeCalls.empty())
117         {
118                 call = m_freeCalls.back();
119                 m_freeCalls.pop_back();
120         }
121
122         // If no free calls were available, create a new.
123         if (!call)
124         {
125                 m_calls.reserve(m_calls.size()+1);
126                 call = new Call();
127                 m_calls.push_back(call);
128         }
129
130         return call;
131 }
132
133 void CallQueue::enqueue (Call* call)
134 {
135         de::ScopedLock lock(m_lock);
136
137         if (m_callQueue.getNumFree() == 0)
138         {
139                 // Call queue must be grown.
140                 m_callQueue.resize(getNextQueueSize(m_callQueue.getSize(), m_callQueue.getSize()+1));
141         }
142
143         m_callQueue.pushFront(call);
144         m_callSem.increment();
145 }
146
147 void CallQueue::freeCall (Call* call)
148 {
149         de::ScopedLock lock(m_lock);
150         m_freeCalls.push_back(call);
151 }
152
153 // Call
154
155 Call::Call (void)
156         : m_func(DE_NULL)
157 {
158 }
159
160 Call::~Call (void)
161 {
162 }
163
164 void Call::clear (void)
165 {
166         m_func = DE_NULL;
167         m_data.clear();
168 }
169
170 // CallReader
171
172 CallReader::CallReader (Call* call)
173         : m_call        (call)
174         , m_curPos      (0)
175 {
176 }
177
178 void CallReader::read (deUint8* bytes, size_t numBytes)
179 {
180         DE_ASSERT(m_curPos + numBytes <= m_call->getDataSize());
181         deMemcpy(bytes, m_call->getData()+m_curPos, numBytes);
182         m_curPos += numBytes;
183 }
184
185 const deUint8* CallReader::getDataBlock (size_t numBytes)
186 {
187         DE_ASSERT(m_curPos + numBytes <= m_call->getDataSize());
188
189         const deUint8* ptr = m_call->getData()+m_curPos;
190         m_curPos += numBytes;
191
192         return ptr;
193 }
194
195 bool CallReader::isDataConsumed (void) const
196 {
197         return m_curPos == m_call->getDataSize();
198 }
199
200 CallReader& operator>> (CallReader& reader, std::string& value)
201 {
202         value.clear();
203         for (;;)
204         {
205                 char c;
206                 reader.read((deUint8*)&c, sizeof(char));
207                 if (c != 0)
208                         value.push_back(c);
209                 else
210                         break;
211         }
212
213         return reader;
214 }
215
216 // CallWriter
217
218 CallWriter::CallWriter (CallQueue* queue, Call::Function function)
219         : m_queue               (queue)
220         , m_call                (queue->getEmptyCall())
221         , m_enqueued    (false)
222 {
223         m_call->setFunction(function);
224 }
225
226 CallWriter::~CallWriter (void)
227 {
228         if (!m_enqueued)
229                 m_queue->freeCall(m_call);
230 }
231
232 void CallWriter::write (const deUint8* bytes, size_t numBytes)
233 {
234         DE_ASSERT(!m_enqueued);
235         size_t curPos = m_call->getDataSize();
236         m_call->setDataSize(curPos+numBytes);
237         deMemcpy(m_call->getData()+curPos, bytes, numBytes);
238 }
239
240 void CallWriter::enqueue (void)
241 {
242         DE_ASSERT(!m_enqueued);
243         m_queue->enqueue(m_call);
244         m_enqueued = true;
245 }
246
247 CallWriter& operator<< (CallWriter& writer, const char* str)
248 {
249         int pos = 0;
250         for (;;)
251         {
252                 writer.write((const deUint8*)str + pos, sizeof(char));
253                 if (str[pos] == 0)
254                         break;
255                 pos += 1;
256         }
257
258         return writer;
259 }
260
261 } // xe