static void read_loop(struct queue *queue, struct debugfs_file *df, int interval) { struct timespec starttime; clock_gettime(CLOCK_MONOTONIC_RAW, &starttime); int64_t target = 0; while (break_loop == 0) { struct timespec currenttime; clock_gettime(CLOCK_MONOTONIC_RAW, ¤ttime); uint64_t host_start = (currenttime.tv_sec - starttime.tv_sec) * 1000000 + (currenttime.tv_nsec - starttime.tv_nsec) / 1000; uint64_t tsf_counter; getTSFRegs(df, &tsf_counter); int slot_count = shmRead16(df, B43_SHM_REGS, COUNT_SLOT); int packet_queued = shmRead16(df, B43_SHM_SHARED, PACKET_TO_TRANSMIT); int transmitted = shmRead16(df, B43_SHM_SHARED, MY_TRANSMISSION); int transmit_success = shmRead16(df, B43_SHM_SHARED, SUCCES_TRANSMISSION); int transmit_other = shmRead16(df, B43_SHM_SHARED, OTHER_TRANSMISSION); clock_gettime(CLOCK_MONOTONIC_RAW, ¤ttime); uint64_t host_finish = (currenttime.tv_sec - starttime.tv_sec) * 1000000 + (currenttime.tv_nsec - starttime.tv_nsec) / 1000; struct slot current_slot = { .host_start = host_start, .host_finish = host_finish, .tsf_counter = tsf_counter, .slot_count = slot_count, .packet_queued = packet_queued, .transmitted = transmitted, .transmit_success = transmit_success, .transmit_other = transmit_other }; queue_push(queue, ¤t_slot); target += interval; int64_t diff = target - host_finish; if (diff > 0) { usleep(diff); } } fprintf(stderr, "Exiting read loop."); usleep(10000); queue_signal(queue); }
void readSlotTimeValue(struct debugfs_file * df, char * file_name){ int i,j,k,l; unsigned int count_slot; unsigned int count_slot_old; unsigned int count_slot_var; unsigned int packet_to_transmit; unsigned int my_transmission; unsigned int succes_transmission; unsigned int other_transmission; long int usec; long int usec_from_start; long int usec_from_current; struct timeval starttime, finishtime; struct timeval start7slot, finish7slot; struct options opt; printf("name file %s\n",file_name); FILE * log_slot_time; log_slot_time = fopen(file_name, "w+"); fprintf(log_slot_time, "num-row,num-read,um-from-start-real,um-from-start-compute,um-diff-time,bytecode-protocol,count-slot,count-slot-var,packet_to_transmit,my_transmission,succes_transmission,other_transmission\n"); gettimeofday(&starttime, NULL); usec_from_current = 0; start7slot= starttime; k=0; for(l=0; l<120; l++){ //it runs for 120 seconds if( (l%2) == 0) //for this experiment every second change bytecode slot opt.active = "1"; else opt.active = "2"; // gettimeofday(&start7slot, NULL); //activation writeAddressBytecode(df,&opt); //change bytecode slot - generally we need from 20ms to 80ms to do it /* gettimeofday(&finish7slot, NULL); usec=(finish7slot.tv_sec-start7slot.tv_sec)*1000000; usec+=(finish7slot.tv_usec-start7slot.tv_usec); printf("%d - %ld\n", j, usec); sleep(1); */ count_slot_old = 0x000F & shmRead16(df, B43_SHM_REGS, COUNT_SLOT); //get current time slot number for(j=0; j<84; j++){//we read metaMAC parameters every 12ms, so we complete 84 cycle in a second //this code read metaMAC parameters //delay usleep(7000); //read meta-MAC value, generally we need 5ms to do it count_slot_old = count_slot & 0x000F; count_slot = shmRead16(df, B43_SHM_REGS, COUNT_SLOT); packet_to_transmit = shmRead16(df, B43_SHM_SHARED, PACKET_TO_TRANSMIT); my_transmission = shmRead16(df, B43_SHM_SHARED, MY_TRANSMISSION); succes_transmission = shmRead16(df, B43_SHM_SHARED, SUCCES_TRANSMISSION); other_transmission = shmRead16(df, B43_SHM_SHARED, OTHER_TRANSMISSION); //compute cycle time gettimeofday(&finish7slot, NULL); usec=(finish7slot.tv_sec-start7slot.tv_sec)*1000000; usec+=(finish7slot.tv_usec-start7slot.tv_usec); usec_from_start = (finish7slot.tv_sec-starttime.tv_sec)*1000000; usec_from_start += (finish7slot.tv_usec-starttime.tv_usec); start7slot = finish7slot; // print debug values printf("%d - %ld\n", j, usec); printf("count_slot:0x%04X - packet_to_transmit:0x%04X - my_transmission:0x%04X - succes_transmission:0x%04X - other_transmission:0x%04X\n", count_slot, packet_to_transmit, my_transmission, succes_transmission, other_transmission); //printf("%d - %d - %s,%d,%d,%ld\n", i, count_change, buffer, 251, 0,usec); // check if cycle time is over, we must be sure to read at least every 16ms if ( count_slot_old == (count_slot & 0x000F) | usec > 16000 | j==0) { // if last cicle is over 16ms or if we change bytecode, we fill time sloc with 0, no information for this slot time printf("read error\n"); if(usec > 100000) exit(1); while(1){ fprintf(log_slot_time,"%d,%d,%ld,%ld,%ld,%c,%d,0,0,0,0,0\n", k, j, usec_from_start, usec_from_current, usec, *opt.active, count_slot & 0x000F); k++; usec_from_current += 2200; if(usec_from_current > usec_from_start ) break; } fflush(log_slot_time); } else { // we extract metaMAC parametes from registers and put it in the log file count_slot_var = count_slot_old; for(i=0; i<7; i++) // we get a maximum of 7 time slots, to safe, we not get the current { fprintf(log_slot_time,"%d,%d,%ld,%ld,%ld,%c,%d,%d,%01x,%01x,%01x,%01x\n", k, j, usec_from_start, usec_from_current, usec, *opt.active, count_slot & 0x000F, count_slot_var, (packet_to_transmit>>count_slot_var) & 0x0001, (my_transmission>>count_slot_var) & 0x0001, (succes_transmission>>count_slot_var) & 0x0001, (other_transmission>>count_slot_var) & 0x0001); k++; usec_from_current += 2200; if(count_slot_var==7) // we increase module 7 count_slot_var=0; else count_slot_var++; if(count_slot_var == (count_slot & 0x000F) ) //we read to the last slot time break; } fflush(log_slot_time); } } } fclose(log_slot_time); printf("read successful\n"); }