245 lines
6.5 KiB
C++
245 lines
6.5 KiB
C++
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
/* ***************************************************************************
|
|
* FastFlow is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU Lesser General Public License version 3 as
|
|
* published by the Free Software Foundation.
|
|
* Starting from version 3.0.1 FastFlow is dual licensed under the GNU LGPLv3
|
|
* or MIT License (https://github.com/ParaGroup/WindFlow/blob/vers3.x/LICENSE.MIT)
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
|
|
#ifndef FF_PLATFORM_HPP
|
|
#define FF_PLATFORM_HPP
|
|
|
|
#include <ff/platforms/liblfds.h>
|
|
|
|
// APPLE specific backward compatibility
|
|
|
|
// posix_memalign is available on OS X starting with 10.6
|
|
#if defined(__APPLE__)
|
|
#include <Availability.h>
|
|
#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
|
|
#define __FF_HAS_POSIX_MEMALIGN 1
|
|
#else
|
|
//#warning "Redefining posix_memalign"
|
|
#include <errno.h>
|
|
inline static int posix_memalign(void **memptr, size_t alignment, size_t size)
|
|
{
|
|
if (memptr && (*memptr = malloc(size))) return 0;
|
|
else return (ENOMEM);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if defined(_WIN32)
|
|
#pragma unmanaged
|
|
|
|
#define NOMINMAX
|
|
|
|
#include <ff/platforms/pthread_minport_windows.h>
|
|
#define INLINE __forceinline
|
|
#define NOINLINE __declspec(noinline)
|
|
//#define CACHE_LINE_SIZE 64
|
|
#define __WIN_ALIGNED_16__ __declspec(align(16))
|
|
|
|
// Thread specific storage
|
|
#define __thread __declspec(thread)
|
|
|
|
|
|
// Only x86 and x86_64 are currently supported for Windows OS
|
|
INLINE void WMB() {}
|
|
INLINE void PAUSE() {}
|
|
|
|
#include <BaseTsd.h>
|
|
typedef SSIZE_T ssize_t;
|
|
|
|
INLINE static int posix_memalign(void **memptr,size_t alignment, size_t sz)
|
|
{
|
|
*memptr = _aligned_malloc(sz, alignment);
|
|
return(!memptr);
|
|
}
|
|
|
|
|
|
INLINE static void posix_memalign_free(void* mem)
|
|
{
|
|
_aligned_free(mem);
|
|
}
|
|
|
|
// Other
|
|
|
|
#include <string>
|
|
typedef unsigned long useconds_t;
|
|
//#define strtoll std::stoll
|
|
#define strtoll _strtoi64
|
|
|
|
#define sleep(SECS) Sleep(SECS)
|
|
|
|
INLINE static int usleep(unsigned long microsecs) {
|
|
if (microsecs > 100000)
|
|
/* At least 100 mS. Typical best resolution is ~ 15ms */
|
|
Sleep (microsecs/ 1000);
|
|
else
|
|
{
|
|
/* Use Sleep for the largest part, and busy-loop for the rest. */
|
|
static double frequency;
|
|
if (frequency == 0)
|
|
{
|
|
LARGE_INTEGER freq;
|
|
if (!QueryPerformanceFrequency (&freq))
|
|
{
|
|
/* Cannot use QueryPerformanceCounter. */
|
|
Sleep (microsecs / 1000);
|
|
return 0;
|
|
}
|
|
frequency = (double) freq.QuadPart / 1000000000.0;
|
|
}
|
|
long long expected_counter_difference = 1000 * microsecs * (long long) frequency;
|
|
int sleep_part = (int) (microsecs) / 1000 - 10;
|
|
LARGE_INTEGER before;
|
|
QueryPerformanceCounter (&before);
|
|
long long expected_counter = before.QuadPart +
|
|
expected_counter_difference;
|
|
if (sleep_part > 0)
|
|
Sleep (sleep_part);
|
|
for (;;)
|
|
{
|
|
LARGE_INTEGER after;
|
|
QueryPerformanceCounter (&after);
|
|
if (after.QuadPart >= expected_counter)
|
|
break;
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
//#define __TICKS2WAIT 1000
|
|
#define random rand
|
|
#define srandom srand
|
|
#define getpid _getpid
|
|
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
|
|
#define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64
|
|
#else
|
|
#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
|
|
#endif
|
|
|
|
/*
|
|
#ifndef _TIMEVAL_DEFINED
|
|
#define _TIMEVAL_DEFINED
|
|
struct timeval {
|
|
long tv_sec;
|
|
long tv_usec;
|
|
};
|
|
#endif
|
|
*/
|
|
|
|
struct timezone
|
|
{
|
|
int tz_minuteswest; /* minutes W of Greenwich */
|
|
int tz_dsttime; /* type of dst correction */
|
|
};
|
|
|
|
INLINE static int gettimeofday(struct timeval *tv, struct timezone *tz)
|
|
{
|
|
FILETIME ft;
|
|
unsigned __int64 tmpres = 0;
|
|
static int tzflag;
|
|
|
|
if (NULL != tv)
|
|
{
|
|
GetSystemTimeAsFileTime(&ft);
|
|
|
|
tmpres |= ft.dwHighDateTime;
|
|
tmpres <<= 32;
|
|
tmpres |= ft.dwLowDateTime;
|
|
|
|
/*converting file time to unix epoch*/
|
|
tmpres -= DELTA_EPOCH_IN_MICROSECS;
|
|
tmpres /= 10; /*convert into microseconds*/
|
|
tv->tv_sec = (long)(tmpres / 1000000UL);
|
|
tv->tv_usec = (long)(tmpres % 1000000UL);
|
|
}
|
|
|
|
if (NULL != tz)
|
|
{
|
|
if (!tzflag)
|
|
{
|
|
_tzset();
|
|
tzflag++;
|
|
}
|
|
tz->tz_minuteswest = _timezone / 60;
|
|
tz->tz_dsttime = _daylight;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//#include <sys/time.h>
|
|
//#include <sys/resource.h>
|
|
//#include <unistd.h>
|
|
|
|
struct rusage {
|
|
struct timeval ru_utime; /* user time used */
|
|
struct timeval ru_stime; /* system time used */
|
|
long ru_maxrss; /* maximum resident set size */
|
|
long ru_ixrss; /* integral shared memory size */
|
|
long ru_idrss; /* integral unshared data size */
|
|
long ru_isrss; /* integral unshared stack size */
|
|
long ru_minflt; /* page reclaims */
|
|
long ru_majflt; /* page faults */
|
|
long ru_nswap; /* swaps */
|
|
long ru_inblock; /* block input operations */
|
|
long ru_oublock; /* block output operations */
|
|
long ru_msgsnd; /* messages sent */
|
|
long ru_msgrcv; /* messages received */
|
|
long ru_nsignals; /* signals received */
|
|
long ru_nvcsw; /* voluntary context switches */
|
|
long ru_nivcsw; /* involuntary context switches */
|
|
};
|
|
|
|
|
|
// sys/uio.h
|
|
|
|
struct iovec
|
|
{
|
|
void* iov_base;
|
|
size_t iov_len;
|
|
};
|
|
|
|
//#include "ff/platforms/platform_msvc_windows.h"
|
|
//#if (!defined(_FF_SYSTEM_HAVE_WIN_PTHREAD))
|
|
//#endif
|
|
#include<algorithm>
|
|
#elif defined(__GNUC__) && (defined(__linux__) || defined(__APPLE__))
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#include <stdlib.h>
|
|
inline static void posix_memalign_free(void* mem)
|
|
{
|
|
free(mem);
|
|
}
|
|
//#define __TICKS2WAIT 1000
|
|
|
|
#else
|
|
# error "unknown platform"
|
|
#endif
|
|
|
|
#endif /* FF_PLATFORM_HPP */
|
|
|
|
|