Merge "Fix extension support checks in negative api tests" into nougat-cts-dev am...
[platform/upstream/VK-GL-CTS.git] / executor / xeCallQueue.hpp
1 #ifndef _XECALLQUEUE_HPP
2 #define _XECALLQUEUE_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Test Executor
5  * ------------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Cross-thread function call dispatcher.
24  *//*--------------------------------------------------------------------*/
25
26 #include "xeDefs.hpp"
27 #include "deMutex.hpp"
28 #include "deSemaphore.hpp"
29 #include "deRingBuffer.hpp"
30
31 #include <vector>
32
33 namespace xe
34 {
35
36 class Call;
37 class CallReader;
38 class CallWriter;
39 class CallQueue;
40
41 // \todo [2012-07-10 pyry] Optimize memory management in Call
42 // \todo [2012-07-10 pyry] CallQueue API could be improved to match TestLog API more closely.
43 //                                                 In order to do that, reference counting system for call object management is needed.
44
45 class Call
46 {
47 public:
48         typedef void (*Function) (CallReader& data);
49
50                                                                 Call                            (void);
51                                                                 ~Call                           (void);
52
53         void                                            clear                           (void);
54
55         Function                                        getFunction                     (void) const    { return m_func;                                }
56         void                                            setFunction                     (Function func) { m_func = func;                                }
57
58         size_t                                          getDataSize                     (void) const    { return m_data.size();                 }
59         void                                            setDataSize                     (size_t size)   { m_data.resize(size);                  }
60
61         const deUint8*                          getData                         (void) const    { return m_data.empty() ? DE_NULL : &m_data[0]; }
62         deUint8*                                        getData                         (void)                  { return m_data.empty() ? DE_NULL : &m_data[0]; }
63
64 private:
65         Function                                        m_func;
66         std::vector<deUint8>            m_data;
67 };
68
69 class CallReader
70 {
71 public:
72                                         CallReader                      (Call* call);
73                                         CallReader                      (void) : m_call(DE_NULL), m_curPos(0) {}
74
75         void                    read                            (deUint8* bytes, size_t numBytes);
76         const deUint8*  getDataBlock            (size_t numBytes);                                      //!< \note Valid only during call.
77         bool                    isDataConsumed          (void) const;                                           //!< all data has been consumed
78
79 private:
80                                         CallReader                      (const CallReader& other);      //!< disallowed
81         CallReader&             operator=                       (const CallReader& other);      //!< disallowed
82
83         Call*                   m_call;
84         size_t                  m_curPos;
85 };
86
87 class CallWriter
88 {
89 public:
90                                         CallWriter                      (CallQueue* queue, Call::Function function);
91                                         ~CallWriter                     (void);
92
93         void                    write                           (const deUint8* bytes, size_t numBytes);
94         void                    enqueue                         (void);
95
96 private:
97                                         CallWriter                      (const CallWriter& other);
98         CallWriter&             operator=                       (const CallWriter& other);
99
100         CallQueue*              m_queue;
101         Call*                   m_call;
102         bool                    m_enqueued;
103 };
104
105 class CallQueue
106 {
107 public:
108                                                         CallQueue                       (void);
109                                                         ~CallQueue                      (void);
110
111         void                                    callNext                        (void); //!< Executes and removes first call in queue. Will block if queue is empty.
112
113         Call*                                   getEmptyCall            (void);
114         void                                    enqueue                         (Call* call);
115         void                                    freeCall                        (Call* call);
116         void                                    cancel                          (void);
117
118 private:
119                                                         CallQueue                       (const CallQueue& other);
120         CallQueue&                              operator=                       (const CallQueue& other);
121
122         bool                                    m_canceled;
123         de::Semaphore                   m_callSem;
124
125         de::Mutex                               m_lock;
126         std::vector<Call*>              m_calls;
127         std::vector<Call*>              m_freeCalls;
128         de::RingBuffer<Call*>   m_callQueue;
129 };
130
131 // Stream operators for call reader / writer.
132
133 CallReader&             operator>>      (CallReader& reader, std::string& value);
134 CallWriter&             operator<<      (CallWriter& writer, const char* str);
135
136 template <typename T>
137 CallReader& operator>> (CallReader& reader, T& value)
138 {
139         reader.read((deUint8*)&value, sizeof(T));
140         return reader;
141 }
142
143 template <typename T>
144 CallWriter& operator<< (CallWriter& writer, T& value)
145 {
146         writer.write((const deUint8*)&value, sizeof(T));
147         return writer;
148 }
149
150 } // xe
151
152 #endif // _XECALLQUEUE_HPP