static int SecureClock_GetTime(int sid, lgoem_dev_rtc_type *time)
{
int sec;
int cur_sec;
if (!checkPriv()) return 0; // no privilege
if (!android::init()) return 0; // binder error
if (!getCurrentTime(&cur_sec)) cur_sec = -1; // get current time as sec
sec = android::gService->GetTime(sid, cur_sec); // get secure time as sec
if (sec < 0) return 0;
rtc_time_to_lg_tm(sec, time);
return 1;
}
// 获取开辟进程数和split词表文件时的时间戳等其他参数，并生成
int getExtraArgs()
{
// 获取词表文件的大小
// 词表文件名：g_pConf->pDictPath/g_pArgs->pDictName
char pTmpName[MAX_NAME];
sprintf(pTmpName, "%s%s", g_pConf->pDictPath, g_pArgs->pDictName);
struct stat statBuffer;
if (Stat(pTmpName, &statBuffer) != 0) {
return -1;
}
// 文件字节大小
int iFileByte = statBuffer.st_size;
const int TMP_SIZE = 10485760; // 10M
int iFileNum = iFileByte / TMP_SIZE + 1; // 向上取整
if (iFileNum > 10) {
iFileNum = 10; // 最多开辟10个线程
}
g_pArgs->iThreadNum = iFileNum; // 赋值给全局线程数
int iPerSize = iFileByte / iFileNum + 5000; // split -C iPerSize -d -a 1 DictName dict_，加5000为了向上取整，避免剩余的字节数单独生成一个文件。
char pStrTime[MAX_NAME];
getCurrentTime(pStrTime);
strcpy(g_pArgs->pStrTimestamp, pStrTime); // 赋值给全局时间戳名
// 创建./dict/timestamp文件夹
sprintf(pTmpName, "%s%s", g_pConf->pDictPath, g_pArgs->pStrTimestamp);
checkDataPath(pTmpName);
// check res file dir exist or not. if not exist, create it.
// 创建./res/
sprintf(pTmpName, "%s", g_pConf->pResPath);
checkDataPath(pTmpName);
sprintf(pTmpName, "%s%s", g_pConf->pResPath, g_pArgs->pStrTimestamp);
checkDataPath(pTmpName);
// 创建时间戳下的online、offline和diff_ret文件夹
sprintf(pTmpName, "%s%s/%s", g_pConf->pResPath, g_pArgs->pStrTimestamp, "online");
checkDataPath(pTmpName);
sprintf(pTmpName, "%s%s/%s", g_pConf->pResPath, g_pArgs->pStrTimestamp, "offline");
checkDataPath(pTmpName);
sprintf(pTmpName, "%s%s/%s", g_pConf->pResPath, g_pArgs->pStrTimestamp, "diff_ret");
checkDataPath(pTmpName);
return splitDictFile(iPerSize);
}
void TouchTest::touchEnded(cocos2d::Touch *touch, cocos2d::Event *event)
{
isTouch = false;
pressTimes = 0;
this->unschedule(schedule_selector(TouchTest::updatelongprogress));
//如果刚完成长按事件 则把按下次数清零 长按状态置空 直接返回 不继续执行
if (m_longProgress) {
touchCounts = 0;
m_longProgress = false;
return;
}
m_endPoint = touch->getLocation();
long long endTime = getCurrentTime();
long long timeDis = endTime - m_startTime;
//E_SWIP_DIR dir = GetSwipDir(m_startPoint, m_endPoint, timeDis);
// if (dir != E_INVAILD) {
// onSwip(m_startPoint, m_endPoint, dir);
// return;
// }
//做连击判断
if (isMoved) {
isMoved = false;
return;
}
if (touchCounts == 2) {
// onThreeClick();
touchCounts = 0;
}
else if (touchCounts == 1) {
this->scheduleOnce(schedule_selector(TouchTest::updateDoubleDelay), 0.25);
touchCounts++;
}
else if (touchCounts == 0) {
this->scheduleOnce(schedule_selector(TouchTest::updateSingleDelay), 0.25);
touchCounts++;
}
}
bool SignalSafeSemaphore::tryEnter(const int seconds, int milliseconds)
{
// Return true in case of success
milliseconds += seconds * 1000;
if (milliseconds == 0)
{
// Instant try
do {
if (sem_trywait(sem) != -1)
return true;
} while (errno == EINTR);
if (errno == EAGAIN)
return false;
system_call_failed::raise("sem_trywait");
}
if (milliseconds < 0)
{
// Unlimited wait, like enter()
do {
if (sem_wait(sem) != -1)
return true;
} while (errno == EINTR);
system_call_failed::raise("sem_wait");
}
// Wait with timeout
timespec timeout = getCurrentTime();
timeout.tv_sec += milliseconds / 1000;
timeout.tv_nsec += (milliseconds % 1000) * 1000000;
timeout.tv_sec += (timeout.tv_nsec / 1000000000l);
timeout.tv_nsec %= 1000000000l;
int errcode = 0;
do {
int rc = sem_timedwait(sem, &timeout);
if (rc == 0)
return true;
// fix for CORE-988, also please see
// http://carcino.gen.nz/tech/linux/glibc_sem_timedwait_errors.php
errcode = rc > 0 ? rc : errno;
} while (errcode == EINTR);
if (errcode == ETIMEDOUT) {
return false;
}
system_call_failed::raise("sem_timedwait", errcode);
return false; // avoid warnings
}
Npc::Npc(const Texture::Name texture, KillCallback killCallback, float speed) {
_sprite = TileSprite::create(TextureAtlas::Loader(texture, 4, 4), 0, 0, 11);
_map = NULL;
_killCallback = killCallback;
_lastPosition = 0.0f;
_physSize = 0;
_positionOffset = 0.0f;
_speedMultip = speed >= 30 ? speed = 29 : (speed < 0 ? speed = 0 : speed);
_lastMoveTime = getCurrentTime();
_moveDirection = 0;
for(int i = 0; i < 4; i++) {
_moveAnimation[i].frames = NULL;
_moveAnimation[i].framesCount = 0;
}
}
void COpcAdapter::SetMTCTagValue(std::string tag, std::string value)
{
#if 1
Agent * agent = _agentconfig->getAgent();
Device *pDev = agent->getDeviceByName(_device);
DataItem *di = pDev->getDeviceDataItem(tag);
if (di != NULL)
{
std::string time = getCurrentTime(GMT_UV_SEC);
agent->addToBuffer(di, value, time);
}
else
{
LOGONCE GLogger.LogMessage(StdStringFormat("(%s) Could not find data item: %s \n", _device.c_str(), tag.c_str()));
}
#endif
}
int getIdentityStringByTime(char *identityString)
{
static char timeBuf[TIMESTRING_BUFFER_SIZE];
static char dateBuf[TIMESTRING_BUFFER_SIZE];
long long curTime;
struct tm tmobj;
tmobj = getCurrentTime();
curTime = getCurrentTimerCounter();
sprintf_s(identityString, IDENTITYSTRING_BUFFER_SIZE,
"%04d%02d%02d-%02d%02d%02d-%lld",
(1900 + tmobj.tm_year), (1 + tmobj.tm_mon), tmobj.tm_mday,
tmobj.tm_hour, tmobj.tm_min, tmobj.tm_sec,
curTime);
return 1;
}
static int
do_comm_select(int msec)
{
int num, saved_errno;
struct timeval tv;
fd_set readfds;
fd_set writefds;
fd_set errfds;
int fd;
if (nreadfds + nwritefds == 0) {
assert(shutting_down);
return COMM_SHUTDOWN;
}
memcpy(&readfds, &global_readfds, sizeof(fd_set));
memcpy(&writefds, &global_writefds, sizeof(fd_set));
memcpy(&errfds, &global_writefds, sizeof(fd_set));
tv.tv_sec = msec / 1000;
tv.tv_usec = (msec % 1000) * 1000;
statCounter.syscalls.selects++;
num = select(Biggest_FD + 1, &readfds, &writefds, &errfds, &tv);
saved_errno = errno;
getCurrentTime();
debug(5, 5) ("do_comm_select: %d fds ready\n", num);
if (num < 0) {
if (ignoreErrno(saved_errno))
return COMM_OK;
debug(5, 1) ("comm_select: select failure: %s\n", xstrerror());
return COMM_ERROR;
}
statHistCount(&statCounter.select_fds_hist, num);
if (num == 0)
return COMM_TIMEOUT;
for (fd = 0; fd <= Biggest_FD; fd++) {
int read_event = FD_ISSET(fd, &readfds);
int write_event = FD_ISSET(fd, &writefds) || FD_ISSET(fd, &errfds);
if (read_event || write_event)
comm_call_handlers(fd, read_event, write_event);
}
return COMM_OK;
}
U32 postEvent(SimObject *destObject, SimEvent* event,U32 time)
{
AssertFatal(time == -1 || time >= getCurrentTime(),
"Sim::postEvent() - Event time must be greater than or equal to the current time." );
AssertFatal(destObject, "Sim::postEvent() - Destination object for event doesn't exist.");
Mutex::lockMutex(gEventQueueMutex);
if( time == -1 )
time = gCurrentTime;
event->time = time;
event->startTime = gCurrentTime;
event->destObject = destObject;
if(!destObject)
{
delete event;
Mutex::unlockMutex(gEventQueueMutex);
return InvalidEventId;
}
event->sequenceCount = gEventSequence++;
SimEvent **walk = &gEventQueue;
SimEvent *current;
while((current = *walk) != NULL && (current->time < event->time))
walk = &(current->nextEvent);
// [tom, 6/24/2005] This ensures that SimEvents are dispatched in the same order that they are posted.
// This is needed to ensure Con::threadSafeExecute() executes script code in the correct order.
while((current = *walk) != NULL && (current->time == event->time))
walk = &(current->nextEvent);
event->nextEvent = current;
*walk = event;
U32 seqCount = event->sequenceCount;
Mutex::unlockMutex(gEventQueueMutex);
return seqCount;
}
void File::readFile(int fd, char* buffer, int size)//,TableManager& tm , FileSystem& fs )
{
TableManager* t = TableManager::getInstance();
TableManager& tm = *t;
FileSystem* f = FileSystem::getInstance();
FileSystem& fs = *f;
InodeElement* inodeE = ((InodeElement*)tm.getElement(INODET, fd));
Inode inode = inodeE->inode;
int blocks = atoi(inode.blocks);
int* dataIdx = new int[blocks];
translateCharArrToIntArr(inode.dataBlockList, dataIdx, blocks);
int filePointer = ((SFTElement*)tm.getElement(SFT, fd))->file_pointer;// (FT) getFilePoint( fd ) fd�� ����Ű�� �ý����������̺��� ���������� �ƿ´�
// �ϳ��� data���� �� �����ͺ��� �л��� �͵��� ��ħ
string data = "";
for (int i = 0; i < blocks; i++)
{
char* blockData;
fs.readFS(dataIdx[i], blockData);
data += blockData;
}
int fileSize = data.length();
if (size == 0) // ���ϳ��� ��ü ���� �� ���
size = fileSize;
else if (fileSize < size) // ����ũ�Ⱑ ����ڰ� ���� size���� ū ���, ���� ���Ͽ� ������ ���븸ŭ���� ������ ����
size = fileSize;
buffer = new char[size];
std::strcpy(buffer, data.substr(filePointer, size).c_str());
tm.updateFilePointer(fd, filePointer + size);
getCurrentTime(inode.time);
// (FT) Inode Block �� time(���� ������ ���ٽð�) ����
tm.updateInode(fd, inode);
// (FS) inode ����
fs.updateInode_readFile(inodeE->inode_number, inode);
}//readFile
static void sineSurf_renderingFunction(cubeFrameBuf *buf)
{
static systemTime_t lastUpdateTime = 0U;
systemTime_t curtime = getSystemTimeUS();
if (0 == lastUpdateTime)
{
lastUpdateTime = curtime;
}
if (lastUpdateTime + SINE_SURF_UPDATE_INTERVAL_US < curtime)
{
lastUpdateTime = getCurrentTime();
g_phase += 2.f * M_PI / (SINE_SURF_ROUND_TIME_US / SINE_SURF_UPDATE_INTERVAL_US);
sineSurf_draw(buf);
}
}
int main(int argc, char **argv){
setbuf(stdout,NULL);
printf("Start\n");
signal(SIGINT, StopServer);
//初始化网络事件循环
g_event_loop = aeCreateEventLoop(1024*10);
long int start_time = getCurrentTime();
/*//设置监听事件
int i;
for(i=0; i<10; i++){
int fd = anetTcpConnect(NULL, argv[1], atoi(argv[2]));
if( ANET_ERR == fd ){
fprintf(stderr, "connect error: %s\n", PORT, NULL);
}
if(anetNonBlock(NULL, fd) == ANET_ERR){
fprintf(stderr, "set nonblock error: %d\n", fd);
}
WriteHandler(g_event_loop, fd, NULL, 0);
}*/
//设置定时事件
aeCreateTimeEvent(g_event_loop, 5000, PrintTimer, NULL, NULL);
//开启事件循环
aeMain(g_event_loop);
//删除事件循环
aeDeleteEventLoop(g_event_loop);
/*printf("End\n");
long int end_time = getCurrentTime();
double elapsed = (double)(end_time-start_time);
printf("test_time : %0.2f s\n", elapsed/1000);
printf("total_req : %d\n", total_req);
printf("total_res : %d\n", total_res);*/
return 0;
}
static int
do_comm_select(int msec)
{
int num;
int i;
if (nfds == 0) {
assert(shutting_down);
return COMM_SHUTDOWN;
}
statCounter.syscalls.selects++;
num = poll(pfds, nfds, msec);
if (num < 0) {
getCurrentTime();
if (ignoreErrno(errno))
return COMM_OK;
debug(5, 1) ("comm_select: poll failure: %s\n", xstrerror());
return COMM_ERROR;
}
statHistCount(&statCounter.select_fds_hist, num);
if (num == 0)
return COMM_TIMEOUT;
for (i = nfds - 1; num > 0 && i >= 0; i--) {
struct pollfd *pfd = &pfds[i];
short read_event, write_event;
if (!pfd->revents)
continue;
read_event = pfd->revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR);
write_event = pfd->revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR);
pfd->revents = 0;
comm_call_handlers(pfd->fd, read_event, write_event);
num--;
}
return COMM_OK;
}
static void report(struct timeval *startTime, unsigned long bytesSent)
{
struct timeval endTime;
unsigned long usec;
float rate;
getCurrentTime(&endTime);
if (endTime.tv_usec < startTime->tv_usec)
{
endTime.tv_sec--;
endTime.tv_usec += 1000000;
}
usec = ((endTime.tv_sec - startTime->tv_sec) * 1000000)
+ (endTime.tv_usec - startTime->tv_usec);
printf("Bytes sent = %lu, usec elapsed = %lu.\n", bytesSent, usec);
rate = (float) (8 * bytesSent) / (float) (usec / 1000000);
printf("Sending %7.2f bits per second.\n", rate);
}
GAE_Clock_t* GAE_Clock_create(void) {
GAE_Clock_t* clock = malloc(sizeof(GAE_Clock_t));
GAE_Clock_Linux_t* linuxClock = malloc(sizeof(GAE_Clock_Linux_t));
struct timespec time;
clock->deltaTime = 0.0F;
clock->currentTime = 0.0F;
clock->isPaused = GAE_FALSE;
clock->platformData = linuxClock;
clock_gettime(CLOCK_MONOTONIC, &time);
linuxClock->startTime = getCurrentTime(&time);
linuxClock->currentTime = linuxClock->startTime;
linuxClock->currentDelta = 0.0;
linuxClock->pausedTime = 0.0;
return clock;
}
void NetInterface::sendConnectRequest(NetConnection *conn)
{
TNLLogMessageV(LogNetInterface, ("Sending Connect Request"));
PacketStream out;
ConnectionParameters &theParams = conn->getConnectionParameters();
out.write(U8(ConnectRequest));
theParams.mNonce.write(&out);
theParams.mServerNonce.write(&out);
out.write(theParams.mClientIdentity);
out.write(theParams.mPuzzleDifficulty);
out.write(theParams.mPuzzleSolution);
U32 encryptPos = 0;
if(out.writeFlag(theParams.mUsingCrypto))
{
out.write(theParams.mPrivateKey->getPublicKey());
encryptPos = out.getBytePosition();
out.setBytePosition(encryptPos);
out.write(SymmetricCipher::KeySize, theParams.mSymmetricKey);
}
out.writeFlag(theParams.mDebugObjectSizes);
out.write(conn->getInitialSendSequence());
out.writeString(conn->getClassName());
conn->writeConnectRequest(&out);
if(encryptPos)
{
// if we're using crypto on this connection,
// then write a hash of everything we wrote into the packet
// key. Then we'll symmetrically encrypt the packet from
// the end of the public key to the end of the signature.
SymmetricCipher theCipher(theParams.mSharedSecret);
out.hashAndEncrypt(NetConnection::MessageSignatureBytes, encryptPos, &theCipher);
}
conn->mConnectSendCount++;
conn->mConnectLastSendTime = getCurrentTime();
out.sendto(mSocket, conn->getNetAddress());
}
void Individual::handle_inherit( const ClothoEvent * evt ) {
const InheritEvent * ie = static_cast< const InheritEvent * >( evt );
if(m_prop->getEOL() != SystemClock::POSITIVE_INFINITY ) {
m_prop->reset();
}
m_prop->inheritFrom( ie->getSender(), ie->getParentSex(), ie->getGamete() );
if( m_prop->getFather() != UNSET_ID && m_prop->getMother() != UNSET_ID ) {
event::vtime_t bday = evt->getReceived();
bday = ((bday / LIFE_CYCLE_PADDING) + 1) * LIFE_CYCLE_PADDING;
BirthEvent * be = BirthEvent::getOrCreate();
be->init( getCurrentTime(), bday, this->getSystemID(), this->getSystemID(), getNextEventID(), m_prop->getSex() );
// handle_birth( evt );
sendEvent( be );
}
}
void MetricBackend_opengl::beginPass() {
if (curPass == 1) {
for (int i = 0; i < QUERY_BOUNDARY_LIST_END; i++) {
for (auto &m : metrics) {
if (m.enabled[i]) m.profiled[i] = true;
}
}
// profile frames in first pass
if (twoPasses) {
if (!supportsTimestamp) {
metrics[METRIC_GPU_DURATION].profiled[QUERY_BOUNDARY_DRAWCALL] = false;
metrics[METRIC_GPU_DURATION].profiled[QUERY_BOUNDARY_CALL] = false;
}
metrics[METRIC_GPU_PIXELS].profiled[QUERY_BOUNDARY_DRAWCALL] = false;
metrics[METRIC_GPU_PIXELS].profiled[QUERY_BOUNDARY_CALL] = false;
}
}
else if (curPass == 2) {
for (int i = 0; i < QUERY_BOUNDARY_LIST_END; i++) {
for (auto &m : metrics) {
m.profiled[i] = false;
}
}
// profile calls/draw calls in second pass
if (!supportsTimestamp) {
if (metrics[METRIC_GPU_DURATION].enabled[QUERY_BOUNDARY_DRAWCALL]) {
metrics[METRIC_GPU_DURATION].profiled[QUERY_BOUNDARY_DRAWCALL] = true;
}
if (metrics[METRIC_GPU_DURATION].enabled[QUERY_BOUNDARY_CALL]) {
metrics[METRIC_GPU_DURATION].profiled[QUERY_BOUNDARY_CALL] = true;
}
}
if (metrics[METRIC_GPU_PIXELS].enabled[QUERY_BOUNDARY_DRAWCALL]) {
metrics[METRIC_GPU_PIXELS].profiled[QUERY_BOUNDARY_DRAWCALL] = true;
}
if (metrics[METRIC_GPU_PIXELS].enabled[QUERY_BOUNDARY_CALL]) {
metrics[METRIC_GPU_PIXELS].profiled[QUERY_BOUNDARY_CALL] = true;
}
}
// setup times
cpuTimeScale = 1.0E9 / getTimeFrequency();
baseTime = getCurrentTime() * cpuTimeScale;
}
void slog(int level, const char *pszFormat, ...) {
char buf[LOGBUFSIZE] = "";
if (level <= _logLevel) {
// calculate the timestamp - dd/mm/yyyy hh:mm:ss
char timestamp[20];
struct tm now;
getCurrentTime(&now);
snprintf(timestamp, 20, "%02d/%02d/%04d %02d:%02d:%02d", now.tm_mday, now.tm_mon + 1, now.tm_year+1900, now.tm_hour, now.tm_min, now.tm_sec);
va_list arglist;
va_start(arglist, pszFormat);
vsnprintf(&buf[strlen(buf)], LOGBUFSIZE - strlen(buf) - 1, pszFormat, arglist);
va_end(arglist);
fprintf(stdout, "(%d - %s): %s", getpid(), timestamp, buf);
flushLog();
}
}
float PerfRenderer::computeFPS()
{
// Calculate frame rate
float currTime=getCurrentTime();
fpsTimes[fpsIndex]=currTime-lastTime;
fpsIndex=(fpsIndex+1)%FPS_AVG_FRAMES;
float avgTime=0.0f;
for(unsigned int i=0;i<FPS_AVG_FRAMES;i++)
avgTime+=fpsTimes[i];
avgTime/=FPS_AVG_FRAMES;
lastTime=currTime;
return 1.0f/avgTime;
}
void HTTPConnector::connectSuccess() noexcept {
if (!cb_) {
return;
}
folly::SocketAddress localAddress;
folly::SocketAddress peerAddress;
socket_->getLocalAddress(&localAddress);
socket_->getPeerAddress(&peerAddress);
std::unique_ptr<HTTPCodec> codec;
transportInfo_.acceptTime = getCurrentTime();
if (transportInfo_.ssl) {
AsyncSSLSocket* sslSocket = dynamic_cast<AsyncSSLSocket*>(socket_.get());
const char* npnProto;
unsigned npnProtoLen;
sslSocket->getSelectedNextProtocol(
reinterpret_cast<const unsigned char**>(&npnProto), &npnProtoLen);
transportInfo_.sslNextProtocol =
std::make_shared<std::string>(npnProto, npnProtoLen);
transportInfo_.sslSetupTime = millisecondsSince(connectStart_);
transportInfo_.sslCipher = sslSocket->getNegotiatedCipherName() ?
std::make_shared<std::string>(sslSocket->getNegotiatedCipherName()) :
nullptr;
transportInfo_.sslVersion = sslSocket->getSSLVersion();
transportInfo_.sslResume = wangle::SSLUtil::getResumeState(sslSocket);
codec = makeCodec(*transportInfo_.sslNextProtocol, forceHTTP1xCodecTo1_1_);
} else {
codec = makeCodec(plaintextProtocol_, forceHTTP1xCodecTo1_1_);
}
HTTPUpstreamSession* session = new HTTPUpstreamSession(
timeoutSet_,
std::move(socket_), localAddress, peerAddress,
std::move(codec), transportInfo_, nullptr);
cb_->connectSuccess(session);
}
void MetricBackend_opengl::endQuery(QueryBoundary boundary) {
if (queryInProgress[boundary]) {
// CPU related
if (metrics[METRIC_CPU_DURATION].profiled[boundary])
{
cpuEnd[boundary] = getCurrentTime();
int64_t time = (cpuEnd[boundary] - cpuStart[boundary]) * cpuTimeScale;
data[METRIC_CPU_DURATION][boundary]->addData(boundary, time);
}
if (metrics[METRIC_CPU_VSIZE_DURATION].profiled[boundary])
{
vsizeEnd[boundary] = os::getVsize();
int64_t time = vsizeEnd[boundary] - vsizeStart[boundary];
data[METRIC_CPU_VSIZE_DURATION][boundary]->addData(boundary, time);
}
if (metrics[METRIC_CPU_RSS_DURATION].profiled[boundary])
{
rssEnd[boundary] = os::getRss();
int64_t time = rssEnd[boundary] - rssStart[boundary];
data[METRIC_CPU_RSS_DURATION][boundary]->addData(boundary, time);
}
// GPU related
if (glQueriesNeeded[boundary]) {
std::array<GLuint, QUERY_LIST_END> &query = queries[boundary].back();
if (metrics[METRIC_GPU_DURATION].profiled[boundary] && supportsTimestamp) {
// GL_TIME_ELAPSED cannot be used in nested queries
// so prefer this if timestamps are supported
glQueryCounter(query[QUERY_GPU_DURATION], GL_TIMESTAMP);
}
if (metrics[METRIC_GPU_PIXELS].profiled[boundary]) {
glEndQuery(GL_SAMPLES_PASSED);
}
}
queryInProgress[boundary] = false;
}
// DRAWCALL is a CALL
if (boundary == QUERY_BOUNDARY_DRAWCALL) endQuery(QUERY_BOUNDARY_CALL);
// clear queries after each frame
if (boundary == QUERY_BOUNDARY_FRAME && glQueriesNeededAnyBoundary) {
processQueries();
}
}
void NetInterface::sendPunchPackets(NetConnection *conn)
{
ConnectionParameters &theParams = conn->getConnectionParameters();
PacketStream out;
out.write(U8(Punch));
if(theParams.mIsInitiator)
theParams.mNonce.write(&out);
else
theParams.mServerNonce.write(&out);
U32 encryptPos = out.getBytePosition();
out.setBytePosition(encryptPos);
if(theParams.mIsInitiator)
theParams.mServerNonce.write(&out);
else
{
theParams.mNonce.write(&out);
if(out.writeFlag(mRequiresKeyExchange || (theParams.mRequestKeyExchange && !mPrivateKey.isNull())))
{
if(out.writeFlag(theParams.mRequestCertificate && !mCertificate.isNull()))
out.write(mCertificate);
else
out.write(mPrivateKey->getPublicKey());
}
}
SymmetricCipher theCipher(theParams.mArrangedSecret);
out.hashAndEncrypt(NetConnection::MessageSignatureBytes, encryptPos, &theCipher);
for(S32 i = 0; i < theParams.mPossibleAddresses.size(); i++)
{
out.sendto(mSocket, theParams.mPossibleAddresses[i]);
TNLLogMessageV(LogNetInterface, ("Sending punch packet (%s, %s) to %s",
ByteBuffer(theParams.mNonce.data, Nonce::NonceSize).encodeBase64()->getBuffer(),
ByteBuffer(theParams.mServerNonce.data, Nonce::NonceSize).encodeBase64()->getBuffer(),
theParams.mPossibleAddresses[i].toString()));
}
conn->mConnectSendCount++;
conn->mConnectLastSendTime = getCurrentTime();
}
void
beginProfile(trace::Call &call, bool isDraw) {
glretrace::Context *currentContext = glretrace::getCurrentContext();
/* Create call query */
CallQuery query;
query.isDraw = isDraw;
query.call = call.no;
query.sig = call.sig;
query.program = currentContext ? currentContext->activeProgram : 0;
glGenQueries(NUM_QUERIES, query.ids);
/* GPU profiling only for draw calls */
if (isDraw) {
if (retrace::profilingGpuTimes) {
if (supportsTimestamp) {
glQueryCounter(query.ids[GPU_START], GL_TIMESTAMP);
}
glBeginQuery(GL_TIME_ELAPSED, query.ids[GPU_DURATION]);
}
if (retrace::profilingPixelsDrawn) {
glBeginQuery(GL_SAMPLES_PASSED, query.ids[OCCLUSION]);
}
}
callQueries.push_back(query);
/* CPU profiling for all calls */
if (retrace::profilingCpuTimes) {
CallQuery& query = callQueries.back();
query.cpuStart = getCurrentTime();
}
if (retrace::profilingMemoryUsage) {
CallQuery& query = callQueries.back();
query.vsizeStart = os::getVsize();
query.rssStart = os::getRss();
}
}
glm::quat CameraRig::predict(float time) {
long long clock_time = getCurrentTime();
float time_diff = (clock_time - rotation_sensor_data_.time_stamp())
/ 1000000000.0f;
glm::vec3 axis = rotation_sensor_data_.gyro();
float angle = glm::length(axis);
if (angle != 0.0f) {
axis /= angle;
}
angle *= (time + time_diff) * 180.0f / M_PI;
glm::quat rotation = rotation_sensor_data_.quaternion()
* glm::angleAxis(angle, axis);
glm::quat transform_rotation = complementary_rotation_ * rotation;
return transform_rotation;
}
void Model::setup()
{
registerBuiltinModules();
// initialize theRootSystem
theRootSystem = createSystem( "System" );
theRootSystem->setID( "/" );
theRootSystem->setName( "The Root System" );
// super system of the root system is itself.
theRootSystem->setSuperSystem( theRootSystem );
// initialize theSystemStepper
theSystemStepper.setModel( this );
theSystemStepper.setID( "___SYSTEM" );
theScheduler.addEvent(
StepperEvent( getCurrentTime() + theSystemStepper.getStepInterval(),
&theSystemStepper ) );
theLastStepper = &theSystemStepper;
}
void
rel_destroy (rel_t *r)
{
// printf("rel_destroy\n");
uint32_t curTime = getCurrentTime();
fprintf(stderr, "RECEIVED TIME: %u SENT TIME: %u\n", curTime, r->startTime);
conn_destroy (r->c);
/* Free any other allocated memory here */
int i;
for (i = 0; i < r->ssThresh; i++) {
free(r->sentPackets[i]->packet);
free(r->sentPackets[i]);
free(r->recvPackets[i]->packet);
free(r->recvPackets[i]);
}
free(r->sentPackets);
free(r->recvPackets);
free(r);
}
int howManyTasks(const char *file)
{
char curTime[30];
FILE *fp = fopen(file,"r");
if (fp == NULL) {
getCurrentTime(curTime);
printf("[%s] Process ID #%d did not terminate successfully.\n", curTime, getpid());
exit(-1);
}
char ch;
int taskCount = 0;
while(!feof(fp))
{
ch = fgetc(fp);
if(ch == '\n')
taskCount++;
}
close(fp);
return taskCount - 1;
}
ThreadState::~ThreadState() {
// if the System.exit method is used to shut down the VM,
// we'll have a non-empty stack frame.
// just mark the current time as the end time
while(!callStack.empty()) {
jlong endTime = getCurrentTime();
StackFrame frame = callStack.top();
callStack.pop();
writeTime(endTime,frame.timeStamp,frame.methodId);
}
if(p!=NULL) {
{
CLock lock(&threadStateLock);
threadStates.erase(this);
}
delete p;
}
p = NULL;
}
void LOPuzzle::touchEnded(void * touch, float x, float y)
{
if (selectedPartsCount>0)
{
screenToButtonsPuzzle(x,y);
if (getCurrentTime()-startTouchTime<0.3 && moveDelta<0.5)
{
rotateParts(selectedParts, selectedPartsCount);
}
for (short i = 0;i<selectedPartsCount;i++)
checkTheConnection(selectedParts[i]);
if (!playConnectSound)
playDropSound = true;
selectedPartsCount = 0;
free(selectedParts);
selectedParts = 0;
}
}
