void initialize_system ()
{
FILE *fconfig;
fconfig = fopen ("config.sys", "r");
fscanf (fconfig, "%d\n", &Observe);
fscanf (fconfig, "%d %d\n", &cpuQuantum, &idleQuantum);
fscanf (fconfig, "%d %d %d %d\n", &pageSize, &memSize, &swapSize, &OSmemSize);
fscanf (fconfig, "%d\n", &periodAgeScan);
fscanf (fconfig, "%d\n", &spoolPsize);
fclose (fconfig);
OriginalPages= find_pages(memSize,pageSize);
OriginalPages_swapspace = find_pages(swapSize,pageSize);
rem_pages = OriginalPages;
rem_pages_swapspace = OriginalPages_swapspace;
#undef num_pages
#define num_pages OriginalPages;
OSpages= find_pages(OSmemSize,pageSize);
printf("OS Size is %d , OS pages are %d\n", OSmemSize, OSpages);
rem_pages= OriginalPages-OSpages;
idlePages= find_pages(3, pageSize);
/*printf("Idle Size is 256, Idle pages are %d, rem pages are %d \n", idlePages, rem_pages);
rem_pages = rem_pages-idlePages;*/
printf("remaining pages are %d\n", rem_pages);
#undef num_pages
#define num_pages rem_pages;
printf("Number of frames in Main memory is %d remaininng pages are %d\n", OriginalPages, rem_pages);
initialize_cpu ();
printf("initialized CPU \n");
initialize_swap_freelist(rem_pages_swapspace, OriginalPages_swapspace);
printf("initialized Swap Space \n");
initialize_freelist(rem_pages, OriginalPages);
printf("initialized Main Memory \n");
initialize_timer ();
printf("initialized timer \n");
initialize_memory ();
printf("initialized memory \n");
initialize_process ();
printf("initialized process \n");
// initialize_memory ();
// printf("initialized memory \n");
}
int initialize_bsp() {
disable_cache_for_section();
initialize_irq_gen_0();
initialize_irq_gen_1();
initialize_timer();
return XST_SUCCESS;
}
int init_workqueue(void)
{
//printk(KERN_INFO "workqueue init called\n");
initialize_timer();//Initializing timer
create_work_queue(); //calling workqueue
//printk(KERN_INFO "workqueue init done\n");
//queue_work( my_wq, &wk1->work );
return 0;
}
int main(int argc, char **argv)
{
// uloop initialize
uloop_init();
// setTimeout
struct uloop_timeout *timeout;
initialize_timer(timeout, SET_TIMEOUT);
// setInternal
struct uloop_timeout *interval;
initialize_timer(interval, SET_INTERVAL);
// loop start
uloop_run();
uloop_done();
return 0;
}
int main (int argv, char** argc)
{
int tds = 1;
int nn = ARRAY_SIZE;
int w = 16;
if (argv > 1) {
tds = atoi(argc[1]);
}
if (argv > 2) {
w = atoi(argc[2]);
}
int w2 = 2*w;
if (ARRAY_SIZE%w2 != 0) {
printf("Error: Array size: %d is not a multiple of 2*weight: %d!\n", ARRAY_SIZE, w2);
exit(-1);
}
int i = 0;
int *sum = (int *)malloc(tds*sizeof(int));
initialize_timer();
start_timer();
#pragma omp parallel num_threads(tds)
{
int tid = 0;
#ifdef OMP
tid = omp_get_thread_num();
#endif
int rr = oneThread(tid, w);
sum[tid] = rr;
}
stop_timer();
double vector_time = elapsed_time();
double gops = (double)((double)((double)((double)4*(double)4)*(double)REPS*((((double)ARRAY_SIZE)/(double)w2)-1.0f)*(double)tds)/vector_time)/((double)1e9);
//double gops = (double)((double)((double)((double)2*(double)4)*(double)REPS*(double)VECTOR_ARRAY_SIZE*(double)ARRAY_SIZE)/vector_time)/((double)1e9);
fprintf(stdout, "Threads: %d ArraySize: %d W: %d time: %.2f s GOPS: %.2f\n", tds, ARRAY_SIZE, w, vector_time, gops);
int out = 0;
for(i = 0; i < tds; i++){
out += sum[i];
}
printf("sum: %d\n", out);
return 0;
}
int main(int argc, char** argv)
{
srand(time(NULL));
initialize_state();
initialize_timer();
print_state(stdout, 1.0f);
printf("Score: %d\n", game_state.score);
char input;
double dTime = 0;
while (1)
{
dTime += get_elapsed_time();
if (dTime > 1)
{
printf("Tick.\n");
dTime -= 1;
}
}
while (input = getchar())
{
switch (input)
{
case 'D':
if (move_down()) return 0;
break;
case 'G':
if (gravity_tick()) return 0;
break;
case 'L':
move_left();
break;
case 'R':
move_right();
break;
case 'U':
rotate();
break;
}
print_state(stdout, 1.0f);
printf("Score: %d\n", game_state.score);
}
return 0;
}
int main()
{
DDRB = 0b00011100;
DDRD = 0b01111100;
sei();
initialize_timer();
serial_init(65);
usi_i2c_slave_address = eeprom_read_byte((uint8_t*)1);
if((usi_i2c_slave_address < 0x04) || (usi_i2c_slave_address > 0x77))
{
//If the stored address is out of range, default to 0x66.
usi_i2c_slave_address = 0x66;
}
//USI_I2C_Init(usi_i2c_slave_address);
//master init
DDR_USI |= (1 << PORT_USI_SDA) | (1 << PORT_USI_SCL);
PORT_USI |= (1 << PORT_USI_SCL);
PORT_USI |= (1 << PORT_USI_SDA);
USIDR = 0xFF;
USICR = (0 << USISIE) | (0 << USIOIE) | (1 << USIWM1) | (0 << USIWM0) | (1 << USICS1) | (0 << USICS0) | (1 << USICLK) | (0 << USITC);
USISR = (1 << USISIF) | (1 << USIOIF) | (1 << USIPF) | (1 << USIDC) | (0x00 << USICNT0);
USI_Slave_register_buffer[0] = (unsigned char*)&step_compare;
USI_Slave_register_buffer[1] = (unsigned char*)(&step_compare)+1;
USI_Slave_register_buffer[2] = (unsigned char*)&step_count;
USI_Slave_register_buffer[3] = (unsigned char*)(&step_count)+1;
USI_Slave_register_buffer[4] = &step_dir;
USI_Slave_register_buffer[5] = &step_mode;
USI_Slave_register_buffer[6] = &step_enabled;
USI_Slave_register_buffer[7] = &step_enabled;
while(1)
{
if(step_compare != OCR1A)
{
OCR1A = step_compare;
}
process_serial_message();
}
}
int main(){
timer_util* tu = malloc(sizeof(timer_util));
int i, j, k;
initialize_timer(tu);
struct histogram* hist = histogram_create(0, 20000, 10);
for(i = 0; i < NUM_TIMER; i++){
timer_set_mode(tu, i, 1);
}
for(i = 0; i < 100; i++){
for(j = 0; j < NUM_TIMER; j++){
timer_start(tu, j);
for(k = 0; k < 1000000; k++){}
timer_end_hist(tu, j, hist);
printf("Timer #%d min: %"PRIu64"\n", j, timer_min(tu, j));
printf("Timer #%d max: %"PRIu64"\n", j, timer_max(tu, j));
printf("Timer #%d avg: %"PRIu64"\n\n", j, timer_avg(tu, j));
}
}
histogram_print(hist);
return 0;
}
extern "C" void __initialize_hardware()
{
// Avoid peripheal libs additional init code.
#define RCC_APB2Periph_SPIz_Enabled
#define RCC_APB2Periph_SPIy_Enabled
#define RCC_APB2Periph_ETH_Enabled
#define RCC_APB2Periph_RC522_Enabled
#define RCC_APB2Periph_RC522_2_Enabled
/* Enable GPIOC clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
/* Configure PC.4 as Output push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure PC.4 as Output push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// initialize peripheal hardware pins.
rc522_set_pins();
rc522_2_set_pins();
enc28j60_set_pins();
// Initilize SPIz hardware settings (pins and spi registers).
set_spi_registers();
set_spi2_registers();
interrupt_initialize();
initialize_timer();
initialize_systick();
}
void task_loop(void *p) {
initialize_timer();
adc->enable_channel(ADC_CH0);
mux->enable();
AdcEvent current_event;
for(;;) {
xQueueReceive(event_queue, ¤t_event, portMAX_DELAY);
switch (current_event) {
case AdcEvent::ADC_SCAN:
{
AnalogSensorMessage msg_to_send;
for (int i = 0; i < 16; ++i) {
uint16_t adc_data;
mux->select_channel(i);
adc->read_value(ADC_CH0, &adc_data);
AdcSensorValue val = MUX_INPUT_POLYNOMIAL_A_VALUES[i] * adc_data + MUX_INPUT_POLYNOMIAL_B_VALUES[i];
msg_to_send.adc_values[i] = val;
}
nav_computer_task::add_message_to_outgoing_frame(msg_to_send);
break;
}
}
}
}
status_t
init_driver(void)
{
struct pci_info *item;
int index;
int cards;
#ifdef DEBUG
set_dprintf_enabled(true);
load_driver_symbols("ipro1000");
#endif
dprintf("ipro1000: " INFO "\n");
item = (pci_info *)malloc(sizeof(pci_info));
if (!item)
return B_NO_MEMORY;
if (get_module(B_PCI_MODULE_NAME, (module_info **)&gPci) < B_OK) {
free(item);
return B_ERROR;
}
for (cards = 0, index = 0; gPci->get_nth_pci_info(index++, item) == B_OK; ) {
const char *info = identify_device(item);
if (info) {
char name[64];
sprintf(name, "net/ipro1000/%d", cards);
dprintf("ipro1000: /dev/%s is a %s\n", name, info);
gDevList[cards] = item;
gDevNameList[cards] = strdup(name);
gDevNameList[cards + 1] = NULL;
cards++;
item = (pci_info *)malloc(sizeof(pci_info));
if (!item)
goto err_outofmem;
if (cards == MAX_CARDS)
break;
}
}
free(item);
if (!cards)
goto err_cards;
if (initialize_timer() != B_OK) {
ERROROUT("timer init failed");
goto err_timer;
}
if (mempool_init(cards * 768) != B_OK) {
ERROROUT("mempool init failed");
goto err_mempool;
}
return B_OK;
err_mempool:
terminate_timer();
err_timer:
err_cards:
err_outofmem:
for (index = 0; index < cards; index++) {
free(gDevList[index]);
free(gDevNameList[index]);
}
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
int main(int argc, char **argv) {
int N;
int t;
int MAX_ITERATION = 2000;
double *prev, *cur;
double error = INIT_VALUE;
// Timer
double time;
// temporary variables
int i,j;
double *temp;
// Check commandline args.
if ( argc > 1 ) {
N = atoi(argv[1]);
} else {
printf("Usage : %s [N]\n", argv[0]);
exit(1);
}
if ( argc > 2 ) {
MAX_ITERATION = atoi(argv[2]);
}
// Memory allocation for data array.
prev = (double *) malloc( sizeof(double) * N * N );
cur = (double *) malloc( sizeof(double) * N * N );
if ( prev == NULL || cur == NULL ) {
printf("[ERROR] : Fail to allocate memory.\n");
exit(1);
}
// Initialization
for ( i=1 ; i < N-1 ; i++ ) {
for ( j=1 ; j < N-1 ; j++ ) {
prev(i,j) = 0.0;
}
}
for ( i=0 ; i < N ; i++ ) {
prev(i , 0 ) = INIT_VALUE;
prev(i , N-1) = INIT_VALUE;
prev(0 , i ) = INIT_VALUE;
prev(N-1, i ) = INIT_VALUE;
cur( i , 0 ) = INIT_VALUE;
cur( i , N-1) = INIT_VALUE;
cur( 0 , i ) = INIT_VALUE;
cur( N-1, i ) = INIT_VALUE;
}
initialize_timer();
start_timer();
// Computation
t = 0;
while ( t < MAX_ITERATION) {
// Computation
#pragma omp parallel for schedule(runtime)
for ( i=1 ; i < N-1 ; i++ )
{
for ( j=1 ; j < N-1 ; j++ )
{
cur(i,j) = ((prev(i-1,j-1)+prev(i-1,j)+prev(i-1,j+1)+prev(i,j-1)+prev(i,j)+prev(i,j+1)+prev(i+1,j-1)+prev(i+1,j)+prev(i+1,j+1)))/9;
}
}
temp = prev;
prev = cur;
cur = temp;
t++;
}
stop_timer();
time = elapsed_time();
printf("Data : %d by %d , Iterations : %d , Time : %lf sec\n", N, N, t, time);
printf("Final data\n");
printMatrix(prev, N);
}
//-- main() ///{{{1///////////////////////////////////////////
int main( int argc, char* argv[] )
{
const char* serverPort = 0;
const char* serverAddress = 0;
// get program arguments (server address and port)
if( argc != 3 )
{
fprintf( stderr, "Error %s arguments\n",
argc < 3 ? "insufficient":"too many"
);
fprintf( stderr, " usage: %s <server> <port>\n", argv[0] );
return 1;
}
serverPort = argv[2];
serverAddress = argv[1];
// initialize timer(s)
# if MEASURE_ROUND_TRIP_TIME
initialize_timer();
# endif
// establish connection to server
int connfd = connect_to_server( serverAddress, serverPort );
if( -1 == connfd )
return 1;
// main loop: read user input, send to server and receive server reply
while( 1 )
{
char inputBuffer[kInputBufferSize];
// get input from user
printf( "Input> " );
if( !fgets( inputBuffer, kInputBufferSize, stdin ) )
break; // typically EOF, possibly error - either way: exit!
// strip trailing '\n'
size_t inputLength = strlen(inputBuffer);
if( inputBuffer[inputLength-1] == '\n' )
inputBuffer[--inputLength] = '\0';
// print status
# if VERBOSE
printf( "Sending string `%s' (%zu bytes)\n", inputBuffer, inputLength );
# endif
// timing - query start time
# if MEASURE_ROUND_TRIP_TIME
double startTime = get_time_stamp();
# endif
// send input to server
ssize_t remaining = inputLength;
while( remaining > 0 )
{
ssize_t offset = inputLength - remaining;
ssize_t ret = send( connfd,
inputBuffer+offset,
remaining,
MSG_NOSIGNAL
);
if( -1 == ret )
{
perror( "send() failed" );
return 1;
}
remaining -= ret;
}
// get response from server
char recvBuffer[kReceiveBufferSize+1];
size_t received = 0;
size_t expected = std::min( kReceiveBufferSize, inputLength );
while( received < expected )
{
ssize_t ret = recv( connfd,
recvBuffer + received,
expected-received,
0
);
if( 0 == ret )
{
fprintf( stderr, "Error - connection closed unexpectedly!\n" );
return 1;
}
if( -1 == ret )
{
perror( "recv() failed" );
return 1;
}
received += ret;
}
// timing - query end time
# if MEASURE_ROUND_TRIP_TIME
double endTime = get_time_stamp();
# endif
// ensure that the received string is zero-terminated
recvBuffer[received] = '\0';
// print output to screen
printf( "Response = `%s'\n", recvBuffer );
# if VERIFY_MESSAGE
bool match = 0 == strncmp( inputBuffer, recvBuffer,
std::min( kInputBufferSize, kReceiveBufferSize )
);
printf( " - response does %smatch original query\n",
match ? "" : "NOT "
);
# endif
# if MEASURE_ROUND_TRIP_TIME
printf( " - round trip time is %f ms\n", (endTime-startTime)*1e3 );
# endif
}
// clean up
close( connfd );
return 0;
}
int main (int argv, char** argc)
{
tds = 1;
// reps = REPS;
if (argv > 1) {
tds = atoi(argc[1]);
}
/* if (argv > 2) {
reps = atoi(argc[2]);
}
*/
int i = 0;
sum = (int *)malloc(tds*sizeof(int));
initialize_timer();
start_timer();
mykernel(NULL);
stop_timer();
double vector_time = elapsed_time();
reset_timer();
start_timer();
mykernel(NULL);
stop_timer();
double vector_time_01 = elapsed_time();
double gops = (double)((double)ARRAY_SIZE*(double)REPS*(double)tds*(double)2)/vector_time/((double)1e9);
double bw = (double)((double)ARRAY_SIZE*(double)REPS)*(double)2*(double)4*(double)tds/vector_time/((double)1e9);
double gops01 = (double)((double)ARRAY_SIZE*(double)REPS*(double)tds*(double)2)/vector_time_01/((double)1e9);
double bw1 = (double)((double)ARRAY_SIZE*(double)REPS)*(double)2*(double)4*(double)tds/vector_time_01/((double)1e9);
fprintf(stdout, "Threads: %d ArraySize: %d time: %.2f s GOPS: %.2f time01: %.2f s GOPS01: %.2f REPS: %d BW: %.2f BW1: %.2f\n", tds, ARRAY_SIZE, vector_time, gops, vector_time_01, gops01, REPS, bw, bw1);
my_papi_profile(mykernel);
/*#pragma omp parallel num_threads(tds)
{
int tid = 0;
#ifdef OMP
tid = omp_get_thread_num();
#endif
int rr = oneThread(tid);
sum[tid] = rr;
}
*/
int out = 0;
for(i = 0; i < tds; i++){
out += sum[i];
}
printf("sum: %d\n", out);
return 0;
}
int main()
{
int i;
int btns_check, sws_check;
int ld9_toggle;
int uiofd0; // AXI timer
int uiofd1; // btns_8bits
int uiofd2; // leds_8bits
int uiofd3; // sws_8bits
const char *uiod0 = "/dev/uio0";
const char *uiod1 = "/dev/uio1";
const char *uiod2 = "/dev/uio2";
const char *uiod3 = "/dev/uio3";
void *uioptr0;
void *uioptr1;
void *uioptr2;
void *uioptr3;
printf("-- Example program --\n");
// Open the UIO devices
uiofd0 = open(uiod0, O_RDWR);
if (uiofd0 < 1) {
printf("Invalid UIO device file:%s.\n", uiod0);
exit(-1);
}
uiofd1 = open(uiod1, O_RDWR);
if (uiofd1 < 1) {
printf("Invalid UIO device file:%s.\n", uiod1);
exit(-1);
}
uiofd2 = open(uiod2, O_RDWR);
if (uiofd2 < 1) {
printf("Invalid UIO device file:%s.\n", uiod2);
exit(-1);
}
uiofd3 = open(uiod3, O_RDWR);
if (uiofd3 < 1) {
printf("Invalid UIO device file:%s.\n", uiod3);
exit(-1);
}
// mmap() the UIO devices
uioptr0 = mmap(NULL, UIO_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, uiofd0, 0);
if (uioptr0 == MAP_FAILED) {
printf("mmap call failure.\n");
exit(-1);
}
uioptr1 = mmap(NULL, UIO_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, uiofd1, 0);
if (uioptr1 == MAP_FAILED) {
printf("mmap call failure.\n");
exit(-1);
}
uioptr2 = mmap(NULL, UIO_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, uiofd2, 0);
if (uioptr2 == MAP_FAILED) {
printf("mmap call failure.\n");
exit(-1);
}
uioptr3 = mmap(NULL, UIO_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, uiofd3, 0);
if (uioptr3 == MAP_FAILED) {
printf("mmap call failure.\n");
exit(-1);
}
// Initialize timer
timer_baseaddr = uioptr0;
timer_baseaddr_u32 = (unsigned int *) uioptr0;
timer_fd = uiofd0;
initialize_timer();
//printf("TCSR0=0x%08X TLR0=0x%08X TCR0=0x%08X\n", read32(timer_baseaddr, 0x0), read32(timer_baseaddr, 0x4), read32(timer_baseaddr, 0x8));
printf("-- Press BTNR push button to change the LD9 toggle --\n");
printf("-- Press BTND push button to start the Timer interrupt --\n");
printf("-- Press BTNL push button to exit --\n");
printf("-- Change slide switches to see corresponding output on LEDs --\n");
ld9_toggle = 0;
//InterruptFlag = 0;
while(1)
{
btns_check = *((volatile unsigned *) uioptr1);
//printf("Buttons Status %x\n", btns_check);
sws_check = *((volatile unsigned *) uioptr3);
//printf("Switches Status %x\n", sws_check);
*((volatile unsigned *) uioptr2) = sws_check;
if ((btns_check & 0x08) == 0x08) {
printf("BTNR is pressed\n");
printf("Changing the LD9 toggle\n");
ld9_toggle = !ld9_toggle; // FIXME
}
if ((btns_check & 0x02) == 0x02) {
printf("BTND is pressed\n");
printf("Starting the Timer\n");
// Start Timer
start_timer();
// Wait for interrupt
wait_for_interrupt();
}
if ((btns_check & 0x04) == 0x04) {
printf("BTNL is pressed\n");
printf("Exiting\n");
break;
}
for (i=0; i<999999999; i++); // delay loop
} // end while loop
printf("-- Exiting main() --\n");
// Unmap the UIO devices
munmap(uioptr0, UIO_SIZE);
munmap(uioptr1, UIO_SIZE);
munmap(uioptr2, UIO_SIZE);
munmap(uioptr3, UIO_SIZE);
return 0;
}
//-- main() ///{{{1///////////////////////////////////////////
int main( int argc, char* argv[] )
{
size_t numClients = 1;
size_t numRepeats = 1;
const char* serverPort = 0;
const char* serverAddress = 0;
// get program arguments (server address and port)
if( argc < 4 || argc > 6 )
{
fprintf( stderr, "Error %s arguments\n",
argc < 4 ? "insufficient":"too many"
);
fprintf( stderr, " synopsis: %s <server> <port> <#num> [<#rep>] [<msg>]\n",
argv[0]
);
fprintf( stderr, " - <#num> -- number of clients to be emulated\n" );
fprintf( stderr, " - <#rep> -- number of times message is sent\n" );
fprintf( stderr, " - <msg> -- message sent by clients (see below)\n" );
fprintf( stderr, "\n" );
fprintf( stderr, "If the client message includes a `%%d' place holder, it\n" );
fprintf( stderr, "is replaced by an unique client id (0 < cid < #clients)\n" );
fprintf( stderr, "before the message is sent to the server.\n" );
fprintf( stderr, "The default message is `%s'\n", g_clientMessage );
return 1;
}
serverPort = argv[2];
serverAddress = argv[1];
numClients = atol(argv[3]);
if( argc >= 5 ) numRepeats = atol(argv[4]);
if( argc >= 6 ) g_clientMessage = argv[5];
// print short status
printf( "Simulating %zu clients.\n", numClients );
// initialize timer(s)
# if MEASURE_ROUND_TRIP_TIME
initialize_timer();
# endif
// resolve address of server once
sockaddr_in servAddr;
if( !resolve_address( servAddr, serverAddress, serverPort ) )
return 1;
// establish N connections (async)
printf( "Establishing %zu connections... \n", numClients );
size_t connErrors = 0;
ConnectionData* connections = new ConnectionData[numClients];
for( size_t i = 0; i < numClients; ++i )
{
# if MEASURE_CONNECT_TIME
connections[i].connectEnd = connections[i].connectStart = -1.0;
connections[i].connectStart = get_time_stamp();
# endif
connections[i].sock = connect_to_server_nonblock( servAddr );
connections[i].state = eConnStateConnecting;
// initialize client aux. data
connections[i].repeatsLeft = numRepeats-1;
# if MEASURE_ROUND_TRIP_TIME
connections[i].roundTripEnd = connections[i].roundTripStart = -1.0;
# endif
// on error: mark client as dead
if( -1 == connections[i].sock )
{
connections[i].state = eConnStateDead;
++connErrors;
}
}
if( connErrors > 0 )
{
printf( " %zu errors while establishing connections\n", connErrors );
if( connErrors == numClients )
{
printf( "All clients errored. Bye\n" );
return 1;
}
}
printf( " successfully initiated %zu connection attempts!\n",
numClients-connErrors );
// event handling loop
size_t clientsAlive = numClients - connErrors;
while( clientsAlive > 0 )
{
int maxfd = 0;
fd_set rset, wset;
FD_ZERO( &rset );
FD_ZERO( &wset );
// put active clients into their respective sets
for( size_t i = 0; i < numClients; ++i )
{
switch( connections[i].state )
{
case eConnStateSending:
case eConnStateConnecting:
FD_SET( connections[i].sock, &wset );
break;
case eConnStateReceiving:
FD_SET( connections[i].sock, &rset );
break;
case eConnStateDead: break;
}
maxfd = std::max( connections[i].sock, maxfd );
}
// wait for any event
int ret = select( maxfd+1, &rset, &wset, 0, 0 );
if( 0 == ret )
{
continue;
}
if( -1 == ret )
{
perror( "select()" );
return 1;
}
// handle events
size_t finishedClients = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].state == eConnStateDead ) continue;
bool keep = true;
if( FD_ISSET( connections[i].sock, &wset ) )
{
keep = client_process_send( i, connections[i] );
}
else if( FD_ISSET( connections[i].sock, &rset ) )
{
keep = client_process_recv( i, connections[i] );
}
if( !keep )
{
close( connections[i].sock );
connections[i].sock = -1;
connections[i].state = eConnStateDead;
++finishedClients;
}
}
clientsAlive -= finishedClients;
}
// gather and display some statistics
# if MEASURE_CONNECT_TIME
{
double avgTime = 0.0;
double maxTime = 0.0;
double minTime = std::numeric_limits<double>::infinity();
size_t timedItems = 0, erroredItems = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].connectEnd < 0.0 )
{
++erroredItems;
continue;
}
double delta = connections[i].connectEnd - connections[i].connectStart;
minTime = std::min( delta, minTime );
maxTime = std::max( delta, maxTime );
avgTime += delta;
++timedItems;
# if VERBOSE
printf( " - conn %zu : connect time = %f ms\n",
i, delta*1e3 );
# endif
}
avgTime /= timedItems;
printf( "Connect timing results for %zu successful connections\n",
timedItems );
printf( " - min time: %f ms\n", minTime*1e3 );
printf( " - max time: %f ms\n", maxTime*1e3 );
printf( " - average time: %f ms\n", avgTime*1e3 );
printf( " (%zu connections failed!)\n", erroredItems );
}
# endif
# if MEASURE_ROUND_TRIP_TIME
{
double avgTime = 0.0;
double maxTime = 0.0;
double minTime = std::numeric_limits<double>::infinity();
size_t timedItems = 0;
for( size_t i = 0; i < numClients; ++i )
{
if( connections[i].roundTripEnd < 0.0 ) continue;
double delta = connections[i].roundTripEnd - connections[i].roundTripStart;
minTime = std::min( delta, minTime );
maxTime = std::max( delta, maxTime );
avgTime += delta;
++timedItems;
# if VERBOSE
printf( " - conn %zu : round trip time = %f ms for %zu round trips\n",
i, delta*1e3, numRepeats );
# endif
}
avgTime /= timedItems;
printf( "Roundtrip timing results for %zu connections for %zu round trips\n",
timedItems, numRepeats );
printf( " - min time: %f ms\n", minTime*1e3 );
printf( " - max time: %f ms\n", maxTime*1e3 );
printf( " - average time: %f ms\n", avgTime*1e3 );
}
# endif
// clean up
for( size_t i = 0; i < numClients; ++i )
close( connections[i].sock );
delete [] connections;
return 0;
}
int main(int ac, char *av[])
{
char *p = NULL;
kern_return_t kr = KERN_FAILURE;
long n;
int ch;
mach_msg_header_t hdr;
while ((ch = getopt(ac, av, "dt:")) != -1)
switch (ch)
{
case 'd': opt_debug = 1; break;
case 't':
n = strtol(optarg, &p, 0);
if ('\0' == optarg[0] || '\0' != *p || n > LONG_MAX || n < 0)
{ fprintf(stderr, "Invalid idle timeout: %s\n", optarg); exit(EXIT_FAILURE); }
maxidle = n;
break;
case '?':
default:
fprintf(stderr, "Usage: mDNSResponderHelper [-d] [-t maxidle]\n");
exit(EXIT_FAILURE);
}
ac -= optind;
av += optind;
(void)ac; // Unused
(void)av; // Unused
initialize_logging();
helplog(ASL_LEVEL_INFO, "Starting");
initialize_id();
#ifndef NO_SECURITYFRAMEWORK
// We should normally be running as a system daemon. However, that might not be the case in some scenarios (e.g. debugging).
// Explicitly ensure that our Keychain operations utilize the system domain.
if (opt_debug) SecKeychainSetPreferenceDomain(kSecPreferencesDomainSystem);
#endif
gPort = register_service(kmDNSHelperServiceName);
if (!gPort)
exit(EXIT_FAILURE);
if (maxidle) actualidle = maxidle;
signal(SIGTERM, handle_sigterm);
if (initialize_timer()) exit(EXIT_FAILURE);
for (n=0; n<100000; n++) if (!gRunLoop) usleep(100);
if (!gRunLoop)
{
helplog(ASL_LEVEL_ERR, "gRunLoop not set after waiting");
exit(EXIT_FAILURE);
}
for(;;)
{
hdr.msgh_bits = 0;
hdr.msgh_local_port = gPort;
hdr.msgh_remote_port = MACH_PORT_NULL;
hdr.msgh_size = sizeof(hdr);
hdr.msgh_id = 0;
kr = mach_msg(&hdr, MACH_RCV_LARGE | MACH_RCV_MSG, 0, hdr.msgh_size, gPort, 0, 0);
if (MACH_RCV_TOO_LARGE != kr)
helplog(ASL_LEVEL_ERR, "main MACH_RCV_MSG error: %d %X %s", kr, kr, mach_error_string(kr));
kr = mach_msg_server_once(helper_server, MAX_MSG_SIZE, gPort,
MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT) | MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0));
if (KERN_SUCCESS != kr)
{ helplog(ASL_LEVEL_ERR, "mach_msg_server: %d %X %s", kr, kr, mach_error_string(kr)); exit(EXIT_FAILURE); }
}
exit(EXIT_SUCCESS);
}
