static mps_addr_t make(void) { size_t length = rnd() % (avLEN * 2); size_t size = (length+2) * sizeof(mps_word_t); mps_addr_t p; mps_res_t res; alloc_bytes += size; for(;;) { mps_bool_t commit_res; double t1, t2; t1 = my_clock(); MPS_RESERVE_BLOCK(res, p, ap, size); t1 = time_since(t1); /* reserve time */ if(res) die(res, "MPS_RESERVE_BLOCK"); res = dylan_init(p, size, exactRoots, exactRootsCOUNT); if(res) die(res, "dylan_init"); t2 = my_clock(); commit_res = mps_commit(ap, p, size); t2 = time_since(t2); /* commit time */ t1 += t2; /* total MPS time for this allocation */ alloc_time += t1; if (t1 > max_alloc_time) max_alloc_time = t1; if (commit_res) break; else ++ commit_failures; } return p; }
int main(int argc, char *argv[]) { int id, ntasks; struct timespec ts0; //char hostname[64]; clock_gettime (CLOCK_MONOTONIC, &ts0); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &id); MPI_Comm_size(MPI_COMM_WORLD, &ntasks); if (id == 0) { fprintf(stderr, "0: completed MPI_Init in %0.3fs. There are %d tasks\n", time_since (ts0)/1000, ntasks); fflush(stdout); } MPI_Barrier(MPI_COMM_WORLD); if (id == 0) { printf("0: completed first barrier\n"); fflush(stdout); } MPI_Finalize(); if (id == 0) { printf("0: completed MPI_Finalize\n"); fflush(stdout); } return 0; }
// The test program (function is called in an endless loop) // Used to display all digits // Activated when both buttons are pressed during system startup // Button 0 switches between continous running mode (where // digits just get incremented every 250ms) and selective mode where // Button 1 is used to increment the digits void test_program(void) { update_buttons(); if(g_buttons[0] && !g_last_buttons[0]) g_last_blink_state = 1 - g_last_blink_state; if(g_last_blink_state == 0) { if(g_buttons[1] && !g_last_buttons[1]) { g_last_blink_action = g_ticks; g_blink_numbers = (g_blink_numbers + 1) % 10; } } else if(time_since(g_last_blink_action) > 25) { g_last_blink_action = g_ticks; g_blink_numbers = (g_blink_numbers + 1) % 10; } set_number(pins_d1, g_blink_numbers); set_number(pins_d2, g_blink_numbers); set_number(pins_d3, g_blink_numbers); set_number(pins_d4, g_blink_numbers); }
//Update button states, I implemented a kind of cooldown //on button actions (high pass filter) to prevent rapid changes //in case the button voltage changes rapidly void update_button(uint8_t index) { g_last_buttons[index] = g_buttons[index]; if(button_pressed(index)) { g_buttons[index] = 1; g_last_button_action[index] = g_ticks; } else if(time_since(g_last_button_action[index]) > 8) { g_buttons[index] = 0; } }
/* Health state machine: * Initial state is UNLOCK. * If Rb, PLL, and GPS are all OK, state becomes OK. * If Rb and PLL are OK, but GPS is UNLOCK, enter HOLDOVER. * If in HOLDOVER and FLL solution becomes too old, enter UNLOCK. * If Rb or PLL are UNLOCK, state is UNLOCK. * Can't go from UNLOCK or HOLDOVER to OK if GPS has MINOR_ALARM, * but if we're currently OK then a MINOR_ALARM won't make us leave. */ void health_update() { health_status_t new_status = health_status; if (health_status == HEALTH_OK && gps_status == GPS_UNLOCK) { if (fll_status == FLL_OK) { new_status = HEALTH_HOLDOVER; } else { new_status = HEALTH_UNLOCK; } } if (health_status == HEALTH_HOLDOVER) { if (fll_status == FLL_UNLOCK) { new_status = HEALTH_UNLOCK; } } if (health_status != HEALTH_UNLOCK) { if (pll_status == PLL_UNLOCK) { new_status = HEALTH_UNLOCK; } if (rb_status == RB_UNLOCK) { new_status = HEALTH_UNLOCK; } } if (health_status != HEALTH_OK) { if (pll_status == PLL_OK && gps_status == GPS_OK && rb_status == RB_OK) { new_status = HEALTH_OK; } } if (new_status != health_status) { health_notify_change("Health", health_status_description, health_status, new_status); if (new_status == HEALTH_OK) { if (entered_holdover_lower != ~0UL || entered_holdover_upper != ~0UL) pll_leave_holdover(time_since(entered_holdover_upper, entered_holdover_lower)); pps_output_enable(); } else if (new_status == HEALTH_HOLDOVER) { entered_holdover_upper = reftime_upper; entered_holdover_lower = reftime_lower; pll_enter_holdover(); } else { pps_output_disable(); } health_status = new_status; } }
static void test_step(mps_arena_t arena, double multiplier) { mps_bool_t res; double t1 = my_clock(); res = mps_arena_step(arena, 0.1, multiplier); cdie(ArenaGlobals(arena)->clamped, "arena was unclamped"); t1 = time_since(t1); if (res) { if (t1 > max_step_time) max_step_time = t1; step_time += t1; ++ steps; } else { if (t1 > max_no_step_time) max_no_step_time = t1; no_step_time += t1; ++ no_steps; } }
/* * Add latency info to latency struct */ static void calc_latency(struct timeval *start_tv, struct timeval *stop_tv, struct io_latency *lat) { double delta; int i; delta = time_since(start_tv, stop_tv); delta = delta * 1000; if (delta > lat->max) lat->max = delta; if (!lat->min || delta < lat->min) lat->min = delta; lat->total_io++; lat->total_lat += delta; for (i = 0 ; i < DEVIATIONS ; i++) { if (delta < deviations[i]) { lat->deviations[i]++; break; } } }
/* * return seconds between start_tv and now in double precision */ static double time_since_now(struct timeval *start_tv) { struct timeval stop_time; gettimeofday(&stop_time, NULL); return time_since(start_tv, &stop_time); }
static int authenticate(int sockfd, const char *username, const char *passwd) { AUTH_HDR *auth; u_short total_length; u_char *ptr; int length; char passbuf[MAXPASS]; u_char md5buf[256]; int secretlen; u_char cbc[AUTH_VECTOR_LEN]; int i, j; u_int32_t ui; struct sockaddr_in saremote; fd_set readfds; socklen_t salen; int retry = retries; /* * Build an authentication request */ auth = (AUTH_HDR *) send_buffer; auth->code = PW_AUTHENTICATION_REQUEST; auth->id = ++request_id; random_vector(vector); memcpy(auth->vector, vector, AUTH_VECTOR_LEN); total_length = AUTH_HDR_LEN; ptr = auth->data; /* * User Name */ *ptr++ = PW_USER_NAME; length = strlen(username); if (length > MAXPWNAM) { length = MAXPWNAM; } *ptr++ = length + 2; memcpy(ptr, username, length); ptr += length; total_length += length + 2; /* * Password */ length = strlen(passwd); if (length > MAXPASS) { length = MAXPASS; } memset(passbuf, 0, MAXPASS); memcpy(passbuf, passwd, length); /* * Length is rounded up to multiple of 16, * and the password is encoded in blocks of 16 * with cipher block chaining */ length = ((length / AUTH_VECTOR_LEN) + 1) * AUTH_VECTOR_LEN; *ptr++ = PW_PASSWORD; *ptr++ = length + 2; secretlen = strlen(secretkey); /* Set up the Cipher block chain */ memcpy(cbc, auth->vector, AUTH_VECTOR_LEN); for (j = 0; j < length; j += AUTH_VECTOR_LEN) { /* Calculate the MD5 Digest */ strcpy((char *)md5buf, secretkey); memcpy(md5buf + secretlen, cbc, AUTH_VECTOR_LEN); md5_calc(cbc, md5buf, secretlen + AUTH_VECTOR_LEN); /* Xor the password into the MD5 digest */ for (i = 0; i < AUTH_VECTOR_LEN; i++) { *ptr++ = (cbc[i] ^= passbuf[j + i]); } } total_length += length + 2; *ptr++ = PW_NAS_PORT_ID; *ptr++ = 6; ui = htonl(nasport); memcpy(ptr, &ui, 4); ptr += 4; total_length += 6; *ptr++ = PW_NAS_PORT_TYPE; *ptr++ = 6; ui = htonl(nasporttype); memcpy(ptr, &ui, 4); ptr += 4; total_length += 6; if (*identifier) { int len = strlen(identifier); *ptr++ = PW_NAS_ID; *ptr++ = len + 2; memcpy(ptr, identifier, len); ptr += len; } else { *ptr++ = PW_NAS_IP_ADDRESS; *ptr++ = 6; ui = htonl(nas_ipaddr); memcpy(ptr, &ui, 4); ptr += 4; total_length += 6; } /* Klaus Weidner <*****@*****.**> changed this * from htonl to htons. It might have caused * you trouble or not. That depends on the byte * order of your system. * The symptom was that the radius server * ignored the requests, because they had zero * length according to the data header. */ auth->length = htons(total_length); while(retry--) { int time_spent; struct timeval sent; /* * Send the request we've built. */ gettimeofday(&sent, NULL); send(sockfd, (char *) auth, total_length, 0); while ((time_spent = time_since(&sent)) < 1000000) { struct timeval tv; int rc, len; if (!time_spent) { tv.tv_sec = 1; tv.tv_usec = 0; } else { tv.tv_sec = 0; tv.tv_usec = 1000000 - time_spent; } FD_ZERO(&readfds); FD_SET(sockfd, &readfds); if (select(sockfd + 1, &readfds, NULL, NULL, &tv) == 0) /* Select timeout */ break; salen = sizeof(saremote); len = recvfrom(sockfd, recv_buffer, sizeof(i_recv_buffer), 0, (struct sockaddr *) &saremote, &salen); if (len < 0) continue; rc = result_recv(saremote.sin_addr.s_addr, saremote.sin_port, recv_buffer, len); if (rc == 0) return 1; if (rc == 1) return 0; } } fprintf(stderr, "%s: No response from RADIUS server\n", progname); return 0; }
int main(int argc, char *argv[]) { if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { Printf("Failed to initialize SDL: %s\n", SDL_GetError()); return -1; } VideoMode mode = {}; mode.width = 800; mode.height = 600; mode.gl_major = 1; mode.gl_minor = 5; mode.double_buffer = 1; mode.depth_bits = 24; mode.stencil_bits = 8; mode.multisamples = 4; mode.swap_interval = 1; SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, mode.gl_major); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, mode.gl_minor); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, mode.double_buffer); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, mode.depth_bits); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, mode.stencil_bits); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, mode.multisamples>0?1:0); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mode.multisamples); mode.window = SDL_CreateWindow( "World Simulator", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode.width, mode.height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE); if (!mode.window) { Printf("Failed to create a window: %s\n", SDL_GetError()); return -1; } SDL_GLContext context = SDL_GL_CreateContext(mode.window); // Note: This must be set on a valid context SDL_GL_SetSwapInterval(mode.swap_interval); SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &mode.gl_major); SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &mode.gl_minor); SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &mode.double_buffer); SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &mode.depth_bits); SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &mode.stencil_bits); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &mode.multisamples); mode.swap_interval = SDL_GL_GetSwapInterval(); sim_init_msgs(false); ImGui_ImplSdl_Init(mode.window); STATE = sim_init((u32)get_tick()); HISTORY_LENGTH = 0; bool running = true; u64 initial_tick = get_tick(); u64 last_frame_t = initial_tick; r32 elapsed_time = 0.0f; r32 delta_time = 1.0f / 60.0f; while (running) { SDL_Event event; while (SDL_PollEvent(&event)) { ImGui_ImplSdl_ProcessEvent(&event); switch (event.type) { case SDL_WINDOWEVENT: { switch (event.window.event) { case SDL_WINDOWEVENT_SIZE_CHANGED: { Printf("Window %d size changed to %dx%d\n", event.window.windowID, event.window.data1, event.window.data2); mode.width = event.window.data1; mode.height = event.window.data2; } break; } } break; case SDL_QUIT: { running = false; } break; } } gui_tick(mode, elapsed_time, delta_time); SDL_GL_SwapWindow(mode.window); delta_time = time_since(last_frame_t); if (mode.fps_lock > 0) { r32 target_time = 1.0f / (r32)mode.fps_lock; r32 sleep_time = target_time - delta_time; if (sleep_time >= 0.01f) SDL_Delay((u32)(sleep_time * 1000.0f)); delta_time = time_since(last_frame_t); } last_frame_t = get_tick(); elapsed_time = time_since(initial_tick); GLenum error = glGetError(); if (error != GL_NO_ERROR) { Printf("An error occurred: %s\n", gl_error_message(error)); running = false; } } ImGui_ImplSdl_Shutdown(); SDL_GL_DeleteContext(context); SDL_DestroyWindow(mode.window); SDL_Quit(); return 0; }
//The main program (this function is called in an endless loop) void main_program(void) { uint8_t output[2]; update_buttons(); dcf77_update(!read_pin(&pin_dcf77), g_ticks); //Menu button pressed? Switch menu mode if(g_buttons[0] && !g_last_buttons[0]) { g_mode = (enum modes_e)((g_mode + 1) % MODE_COUNT); switch(g_mode) { case MODE_SET_HOURS: case MODE_SET_DAY: g_blink_numbers = 1; break; case MODE_SET_MINUTES: case MODE_SET_MONTH: g_blink_numbers = 2; break; default: g_blink_numbers = 0; }; g_last_blink_action = g_ticks; g_last_blink_state = 1; g_last_inc_action = g_ticks; g_inc_pressed_time = g_ticks; } if(g_mode != MODE_NORMAL) //Inside Setup-mode? { //date/inc buttons pressed if(g_buttons[1]) { if(!g_last_buttons[1]) { on_increment_pressed(); g_inc_pressed_time = g_ticks; } //Increment continously if pressed & hold if(time_since(g_inc_pressed_time) > 100 && time_since(g_last_inc_action) > 15) { g_last_inc_action = g_ticks; on_increment_pressed(); } } //Are we currently setting time or date? display the appropriate output if(g_mode == MODE_SET_HOURS || g_mode == MODE_SET_MINUTES) { output[0] = g_time.hours; output[1] = g_time.minutes; } else { output[0] = g_time.day; output[1] = g_time.month; } // handle blinking of modifiable numbers if(g_blink_numbers != 0) { if(time_since(g_last_blink_action) > 50) { g_last_blink_action = g_ticks; g_last_blink_state = !g_last_blink_state; } // Going beyond single-digit range of the display // should turn the digit off if(g_last_blink_state == 0) output[g_blink_numbers-1] = 0xFF; } } else //normal operation (non-setup) { if(g_buttons[1]) { output[0] = g_time.day; output[1] = g_time.month; } else { output[0] = g_time.hours; output[1] = g_time.minutes; } } write_output(output[0], output[1]); }
uint32_t health_get_ref_age() { return time_since(reftime_upper, reftime_lower); }