double TTimer::GetTimer()
{
double t=0;
pthread_mutex_lock(&mutex);
if(!init){
init=true;
ClockGetTime(CLOCK_MONOTONIC,&t0);
}else{
timespec t1;
ClockGetTime(CLOCK_MONOTONIC,&t1);
t=util::dift(t1,t0);
}
pthread_mutex_unlock(&mutex);
return t;
}
/*
* @brief Print all the pending activities in the system
*/
void
PwrEventActivityPrint(void)
{
struct timespec now;
ClockGetTime(&now);
_activity_print(&now, &now);
}
/**
* @brief Prints the activities active in range from
* time 'start' to now.
*
* @param from
*/
void
PwrEventActivityPrintFrom(struct timespec *start)
{
struct timespec now;
ClockGetTime(&now);
_activity_print(start, &now);
}
/**
* Pretty print the current time.
*/
void
ClockPrint(void)
{
struct timespec time;
ClockGetTime(&time);
ClockPrintTime(&time);
}
/**
* Render the tiles for a frame.
* @param xOffset the leftmost X coordinate
* @param yOffset the topmost Y coordinate
* @todo This can be simplified and improved significantly by just rendering a
* pre-created vertex array of the entire tilemap on each frame. It will
* reduce overhead and actually be faster.
*/
void GLTileEngine::renderTiles()
{
static uint64_t lasttime = 0;
int width = this->width, height = this->height;
int xOffset = this->xOffset, yOffset = this->yOffset;
xOffset &= 0xfffffff0;
yOffset &= 0xfffffff0;
glBindTexture(GL_TEXTURE_2D, this->texture);
GLenum filter = this->scale == 1.0f ? GL_NEAREST : GL_LINEAR;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
// do the actual drawing
glBegin(GL_QUADS);
for(int y=yOffset; y <= this->yMax; y+=16)
{
for(int x=xOffset; x <= this->xMax; x+=16)
{
int tileX = x>>4;
int tileY = y>>4;
if(tileX < 0 || tileX >= WORLD_W || tileY < 0 || tileY >= WORLD_H)
continue;
int tile = *(unsigned short*)(this->tiles + ROW_BYTES*tileY + COL_BYTES*tileX) & LOMASK;
renderTile(x, y, tile);
}
}
glEnd();
if(lasttime)
printf("FPS: %f\r", 1000000.0/(ClockGetTime()-lasttime));
lasttime = ClockGetTime();
}
/* void ClockGetTime(struct timespec *time) */
static void
test_ClockGetTime(void)
{
struct timespec time;
ClockGetTime(&time);
/* Check if the values are sane. */
g_assert_cmpint(time.tv_sec, >, 0); /* seconds - TYPE_T (long int) */
g_assert(time.tv_nsec > 0); /* nanoseconds - long int */
/* The value should always be less than one second. */
int nsecToSec = time.tv_sec / NSEC_PER_SEC;
g_assert_cmpint(nsecToSec, <, 1);
}
void *check_list(void *arg) {
while (RUNNING) {
pthread_mutex_lock(&m_datagram_list);
struct timespec now;
ClockGetTime(&now);
ListRemoveByTimeout(&datagram_list, now);
pthread_mutex_unlock(&m_datagram_list);
usleep(LIST_FREQUENCY);
}
return NULL;
}
ULONG32 GetTickCount()
{
TickSpec ticks;
TimeSpec time;
if (_clock == NULL)
{
_clock = ClockCreate(SYSTEM_CLOCK);
if (_clock == NULL)
{
return 0;
}
g_RegisterGlobalPtr(&_clock);
}
ClockGetTime(_clock, &ticks);
ClockConvertToTime(_clock, &ticks, &time);
return (time.tv_sec * 1000) + (time.tv_nsec / 1000000);
}
NTSTATUS
NTAPI
ClockPropertyTime(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data)
{
PLONGLONG Time = (PLONGLONG)Data;
PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
DPRINT("ClockPropertyTime\n");
*Time = ClockGetTime(IoStack->FileObject);
Irp->IoStatus.Information = sizeof(LONGLONG);
return STATUS_SUCCESS;
}
void send_ack(int ack, int sockfd, struct sockaddr *server, socklen_t server_l) {
struct message_t resp;
resp.id = GetNewMessageID();
resp.type = POTVRDA;
sprintf(resp.data, "%d", ack);
ClockGetTime(&resp.timeout);
ClockAddTimeout(&resp.timeout, TIMEOUT);
#ifdef DEBUG
printf("Sending ACK for message %d\n", ack);
#endif
sendto(sockfd, &resp, sizeof(resp), 0, server, server_l);
return;
}
void *tipke(void *arg) {
char cmd[MAX_BUFF];
int floor;
struct message_t msg;
/* do tipke things */
while (RUNNING) {
memset(cmd, 0, sizeof(cmd));
/* format: floor direction*/
scanf("%d%s", &floor, cmd);
if (*cmd == 'a' && floor != 9) {
msg.type = TIPKE_KEY_PRESSED_UP;
} else if (*cmd == 'z' && floor != 0) {
msg.type = TIPKE_KEY_PRESSED_DOWN;
} else {
warnx("Unkown command (use 'a' for UP and 'z' for down)!");
continue;
}
msg.id = GetNewMessageID();
memset(msg.data, 0, sizeof(msg.data));
sprintf(msg.data, "%d", floor);
ClockGetTime(&msg.timeout);
ClockAddTimeout(&msg.timeout, TIMEOUT);
pthread_mutex_lock(&m_datagram_list);
sendto(upr_socket, &msg, sizeof(msg), 0, &upr_server, upr_server_l);
ListInsert(&datagram_list, msg);
pthread_mutex_unlock(&m_datagram_list);
}
return NULL;
}
static Activity *
_activity_new(const char *activity_id, int duration_ms)
{
if (duration_ms >= ACTIVITY_MAX_DURATION_MS)
{
duration_ms = ACTIVITY_MAX_DURATION_MS;
}
Activity *activity = g_new0(Activity, 1);
activity->activity_id = g_strdup(activity_id);
activity->duration_ms = duration_ms;
// end += duration
ClockGetTime(&activity->start_time);
activity->end_time.tv_sec = activity->start_time.tv_sec;
activity->end_time.tv_nsec = activity->start_time.tv_nsec;
ClockAccumMs(&activity->end_time, activity->duration_ms);
return activity;
}
void *udp_listener(void *arg) {
char tipke_hostname[MAX_BUFF], tipke_port[MAX_BUFF];
int server_socket;
int ack, floor;
struct message_t msg;
struct sockaddr client;
socklen_t client_l = sizeof(client);
ParseHostnameAndPort("TIPKE", (char **) &tipke_hostname, (char **) &tipke_port);
#ifdef DEBUG
printf("Listening as TIPKE on %s:%s\n", tipke_hostname, tipke_port);
#endif
server_socket = InitUDPServer(tipke_port);
#ifdef DEBUG
printf("Server started successfully\n");
#endif
while (RUNNING) {
/* waiting for next datagram */
recvfrom(server_socket, &msg, sizeof(msg), 0, &client, &client_l);
switch(msg.type) {
case POTVRDA:
/* received ack */
pthread_mutex_lock(&m_datagram_list);
sscanf(msg.data, "%d", &ack);
#ifdef DEBUG
printf("Received ACK for message %d\n", ack);
#endif
ListRemoveById(&datagram_list, ack);
pthread_mutex_unlock(&m_datagram_list);
break;
case TIPKE_PALI_LAMPICU_UP:
send_ack(msg.id, upr_socket, &upr_server, upr_server_l);
pthread_mutex_lock(&m_status);
sscanf(msg.data, "%d", &floor);
status[floor][D_UP] = 1;
pthread_mutex_unlock(&m_status);
PrintStatus();
break;
case TIPKE_PALI_LAMPICU_DOWN:
send_ack(msg.id, upr_socket, &upr_server, upr_server_l);
pthread_mutex_lock(&m_status);
sscanf(msg.data, "%d", &floor);
status[floor][D_DOWN] = 1;
pthread_mutex_unlock(&m_status);
PrintStatus();
break;
case TIPKE_GASI_LAMPICU_UP:
send_ack(msg.id, upr_socket, &upr_server, upr_server_l);
pthread_mutex_lock(&m_status);
sscanf(msg.data, "%d", &floor);
status[floor][D_UP] = 0;
pthread_mutex_unlock(&m_status);
PrintStatus();
break;
case TIPKE_GASI_LAMPICU_DOWN:
send_ack(msg.id, upr_socket, &upr_server, upr_server_l);
pthread_mutex_lock(&m_status);
sscanf(msg.data, "%d", &floor);
status[floor][D_DOWN] = 0;
pthread_mutex_unlock(&m_status);
PrintStatus();
break;
case TIPKE_STATUS_REQUEST:
send_ack(msg.id, upr_socket, &upr_server, upr_server_l);
msg.id = GetNewMessageID();
msg.type = TIPKE_STATUS_REPORT;
ClockGetTime(&msg.timeout);
ClockAddTimeout(&msg.timeout, TIMEOUT);
pthread_mutex_lock(&m_datagram_list);
sendto(upr_socket, &msg, sizeof(msg), 0, &upr_server, upr_server_l);
ListInsert(&datagram_list, msg);
pthread_mutex_unlock(&m_datagram_list);
break;
default:
warnx("Unknown message!");
break;
}
}
CloseUDPServer(server_socket);
#ifdef DEBUG
printf("Server closed successfully\n");
#endif
return NULL;
}
