-
Notifications
You must be signed in to change notification settings - Fork 8
/
sysutils.h
456 lines (342 loc) · 11.3 KB
/
sysutils.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
#ifndef INCLUDED_SYSUTIL_H
#define INCLUDED_SYSUTIL_H
//////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2011-2012, OblakSoft LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//
// Authors: Maxim Mazeev <mazeev@hotmail.com>
// Artem Livshits <artem.livshits@gmail.com>
//////////////////////////////////////////////////////////////////////////////
// System level classes and common utils.
//////////////////////////////////////////////////////////////////////////////
#include <stddef.h> // needed for __WORDSIZE and size_t
#include <string>
#include <vector>
namespace webstor
{
namespace internal
{
//////////////////////////////////////////////////////////////////////////////
// Debugging support.
#ifdef DEBUG
typedef bool ( dbgShowAssertFunc )( const char *file, int line, const char *msg, bool *ignoreAll );
extern dbgShowAssertFunc *g_dbgShowAssertFunc_;
#ifdef _MSC_VER
#define dbgBreak_ __debugbreak()
#elif defined( __GNUC__ )
extern volatile int g_fakeGlobalForDbgBreak_;
#define dbgBreak_ do { asm __volatile__ ( "int3" ); g_fakeGlobalForDbgBreak_ = 0; } while( 0 )
#else
#define dbgBreak_
#endif
#define dbgAssertSz( cond, sz ) \
do \
{ \
static bool s_ignoreAll = false; \
if( !s_ignoreAll && !( cond ) && \
( !g_dbgShowAssertFunc_ || ( *g_dbgShowAssertFunc_ )( __FILE__, __LINE__, sz, &s_ignoreAll ) ) ) \
dbgBreak_; \
} while( 0 )
#define dbgVerify( a ) dbgAssert( a )
#define ifDebug( a ) a
#else // !DEBUG
#define dbgAssertSz( cond, sz ) do {} while( 0 )
#define dbgVerify( a ) do { if( !( a ) ); } while( 0 )
#define ifDebug( a )
#endif // !DEBUG
#define dbgAssert( a ) dbgAssertSz( a, "Assertion failed: " #a )
#define dbgPanicSz( a ) dbgAssertSz( 0, a )
// This needs to be a macro so that short-circuiting happens
// (i.e. 'b' isn't evaluated unless 'a' is true).
#define implies( a, b ) ( !( a ) || ( b ) )
//////////////////////////////////////////////////////////////////////////////
// Compile-time asserts.
#define CASSERT( a ) typedef int compile_time_assert_failed__[ ( a ) ? 1 : -1 ]
//////////////////////////////////////////////////////////////////////////////
// Tracing support.
// #define WEBSTOR_ENABLE_DBG_TRACING
#ifdef WEBSTOR_ENABLE_DBG_TRACING
void
logTrace( const char *fmt, ... );
#define LOG_TRACE( fmt, ... ) logTrace( "%llu " fmt "\n", timeElapsed(), __VA_ARGS__ )
#else // !WEBSTOR_ENABLE_DBG_TRACING
#define LOG_TRACE( fmt, ... )
#endif // !WEBSTOR_ENABLE_DBG_TRACING
//////////////////////////////////////////////////////////////////////////////
// Integer types.
typedef signed int Int32;
typedef unsigned int UInt32;
typedef signed long long Int64;
typedef unsigned long long UInt64;
CASSERT( sizeof( UInt64 ) == sizeof( UInt32 ) * 2 );
//////////////////////////////////////////////////////////////////////////////
// Built-in array dimension operator and other helper macros.
template < class T, size_t N > char ( *dimensionOfHelper_( T( & )[ N ] ) )[ N ];
#define dimensionOf( a ) sizeof( *webstor::internal::dimensionOfHelper_( a ) )
#define STRING_WITH_LEN( str ) ( str ), dimensionOf( str ) - 1
struct StringWithLen
{
const char * str;
size_t len;
};
//////////////////////////////////////////////////////////////////////////////
// Scoped resource (similar to auto_ptr/unique_ptr but for any resource that
// has a custom deleter).
template < class Type, class Deleter, UInt64 emptyValue = 0 >
class auto_scope
{
public:
explicit auto_scope( Type o = ( Type )emptyValue ) : m_obj( o ) {}
~auto_scope() { if( m_obj != ( Type )emptyValue ) Deleter::free( m_obj ); }
Type release() { Type o = m_obj; m_obj = ( Type )emptyValue; return o; }
void reset( Type o ) { if( m_obj != ( Type )emptyValue ) Deleter::free( m_obj ); m_obj = o; }
operator Type() const { return m_obj; }
Type operator->() const { dbgAssert( !empty() ); return m_obj; }
bool empty() const { return m_obj == ( Type )emptyValue; }
Type * unsafeAddress() { dbgAssert( empty() ); return &m_obj; }
private:
auto_scope( const auto_scope & );
auto_scope& operator=( const auto_scope & );
Type m_obj;
};
//////////////////////////////////////////////////////////////////////////////
// Memory fences (barriers).
#ifdef _MSC_VER
extern "C" void _mm_lfence(void);
extern "C" void _mm_mfence(void);
#pragma intrinsic (_mm_lfence)
#pragma intrinsic (_mm_mfence)
inline void
cpuMemLoadFence()
{
_mm_lfence();
}
inline void
cpuMemStoreFence()
{
_mm_mfence();
}
inline void
cpuMemFullFence()
{
_mm_mfence();
}
#else // !_MSC_VER
inline void
cpuMemLoadFence()
{
__sync_synchronize();
}
inline void
cpuMemStoreFence()
{
__sync_synchronize();
}
inline void
cpuMemFullFence()
{
__sync_synchronize();
}
#endif // !_MSC_VER
//////////////////////////////////////////////////////////////////////////////
// EventSync -- event synchronization primitive.
class EventSync
{
friend class SocketPool;
public:
enum { c_infinite = -1 };
EventSync( bool initialState = false );
~EventSync();
void set(); // nofail
void reset(); // nofail
bool wait( UInt32 msTimeout = c_infinite ) const; // nofail
// Waits for any, returns -1 if timeout.
// count must be <= c_maxEventCount.
enum { c_maxEventCount = 64 };
static int waitAny( EventSync **events, size_t count, UInt32 msTimeout = c_infinite );
private:
EventSync( const EventSync& );
EventSync& operator=( const EventSync& );
#ifdef _WIN32
void *m_handle;
#else
int m_handle;
#endif
};
//////////////////////////////////////////////////////////////////////////////
// ExLockSync -- exclusive lock.
class ExLockSync
{
#ifdef _WIN32
struct Data // Stub for CRITICAL_SECTION
{
void * reserved1_;
UInt32 reserved2_[ 2 ];
void * reserved3_[ 3 ];
};
#else // !_WIN32
union Data // Stub for pthread_mutex_t
{
struct
{
int reserved1_;
unsigned reserved2_;
int reserved3_;
#if __WORDSIZE == 64
unsigned reserved4_;
#endif
int reserved5_;
#if __WORDSIZE == 64
int reserved6_;
void * reserved7_;
#else // __WORDSIZE != 64
unsigned reserved6_;
__extension__ union
{
int reserved7_;
void * reserved8_;
};
#endif // __WORDSIZE != 64
} reserved9_;
#if __WORDSIZE == 64
char reserved10_[ 40 ];
#else
char reserved10_[ 24 ];
#endif
long reserved11_;
};
#endif // !_WIN32
public:
ExLockSync();
~ExLockSync();
void claimLock(); // nofail
void releaseLock(); // nofail
#ifdef DEBUG
bool dbgHoldLock() const { return m_lockOwner != 0; }
#endif
private:
ExLockSync( const ExLockSync & ); // forbidden
ExLockSync & operator=( const ExLockSync & ); // forbidden
Data m_data;
#ifdef DEBUG
UInt64 m_lockOwner;
#endif
};
//////////////////////////////////////////////////////////////////////////////
// ScopedExLock -- scoped exclusive lock.
struct ExLockDeleter
{
static void free( ExLockSync *pels ) { dbgAssert( pels ); pels->releaseLock(); }
};
typedef auto_scope< ExLockSync *, ExLockDeleter > ScopedExLock;
//////////////////////////////////////////////////////////////////////////////
// SocketPool -- a collection of sockets with interruptible wait.
#ifdef _WIN32
typedef void *SocketHandle;
#else
typedef int SocketHandle;
#endif
#define INVALID_SOCKET_HANDLE ( ( SocketHandle )( -1 ) )
enum SocketAction
{
SA_POLL_IN = 1,
SA_POLL_OUT = 2,
SA_POLL_ERR = 4
};
typedef UInt32 SocketActionMask;
typedef std::vector< std::pair< SocketHandle, SocketActionMask > > SocketActions;
struct SocketPoolState;
class SocketPool
{
public:
SocketPool();
~SocketPool();
bool add( SocketHandle socket, SocketActionMask actionMask ); // nofail
bool remove( SocketHandle socket ); // nofail
void reserve( size_t size );
size_t size() const; // nofail
void signal(); // nofail
bool wait( UInt32 msTimeout, UInt32 msInterruptOnlyTimeout, SocketActions *socketActions );
private:
SocketPool( const SocketPool & ); // forbidden
SocketPool & operator=( const SocketPool & ); // forbidden
SocketPoolState * m_pool;
EventSync m_interrupt;
};
//////////////////////////////////////////////////////////////////////////////
// Socket tuning.
struct TcpKeepAliveParams
{
// How long to stay in idle before sending keepalive probe, in milliseconds.
int probeStartTime;
// Delay between TCP keepalive probes, in milliseconds.
int probeIntervalTime;
// The number of unacknowledged probes to send before considering the connection dead.
int probeCount;
};
// Enable/Disable TCP KeepAlive.
void
setTcpKeepAlive( SocketHandle socket, const TcpKeepAliveParams *params );
// Change Send/Receive buffer size.
void
setSocketBuffers( SocketHandle socket, UInt32 size );
//////////////////////////////////////////////////////////////////////////////
// TaskCtrl -- asynchronous task control.
#ifdef _WIN32
typedef void * TaskHandle;
#else
typedef unsigned long TaskHandle;
#endif
struct TaskCtrlDeleter
{
static void free( TaskHandle handle );
};
class TaskCtrl : public auto_scope< TaskHandle, TaskCtrlDeleter >
{
public:
void wait() const; // nofail
};
//////////////////////////////////////////////////////////////////////////////
// Task utilities.
#ifdef _WIN32
typedef unsigned long TaskResult;
#define TASKAPI __stdcall
#else
typedef void * TaskResult;
#define TASKAPI
#endif
typedef UInt64 TaskId;
const TaskId c_invalidTaskId = 0;
typedef TaskResult ( TASKAPI TaskFn )( void *arg );
void
taskStartAsync( TaskFn *taskFn, void *arg, TaskCtrl *pctrl );
void
taskSleep( UInt32 msTimeout ); // nofail
//////////////////////////////////////////////////////////////////////////////
// Stopwatch to measure time intervals.
class Stopwatch
{
public:
Stopwatch( bool _start = false );
void start(); // nofail
UInt64 elapsed(); // nofail
private:
UInt64 m_startTime;
};
UInt64
timeElapsed(); // nofail, in milliseconds.
} // namespace internal
} // namespace webstor
#endif // !INCLUDED_SYSUTIL_H