[Qemu-devel] Help with USB packet transmission rate

[Programmingkid]

The USB Start of Frame packet is sent 1000 times a second from the host to a USB device. This packet is used to synchronize audio data being sent to a USB sound card. On my system the Start of Frame packet is only sent about 830 times a second. This makes audio that is played thru the USB sound card sound kind of slow. 

Research into the problem indicates the rate QEMU is suppose to send the packet isn't actually being done. How it is set up now the emulated sound hardware just assumes the rate it is suppose to send data is what actually happens. This isn't true. More variables need to be accounted for. 

What I propose is code be made that actively monitors how many Start of Frame packets are being sent in a given second. If the value goes down, then QEMU should compensate and try to send more Start of Frame packets. If the value goes too high, QEMU should throttle back on Start of Frame packet transmission. 

This code is basically what I think should be put into place to help maintain a consistent Start of Frame packet transmission rate. This code is easy to build yourself and try out. What it does is makes two threads. One is a consumer and the other is a producer thread. The consumer thread monitors the production of the producer thread. The consumer thread can actively adjust the rate of the producer thread to help it maintain a steady pace. You can test this program out by having it run and seeing how its values change when you do CPU intensive stuff. What I do is open a YouTube video and scroll in the window really fast to see how the program adapts. 

I would like to know if this looks like something that could do a good job at maintaining a steady Start of Frame packet transmission rate. I'm hoping for more suggestions and improvements I could make to this program before I try to implement it in the hcd-ohci.c file. 

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

#include <memory.h>

#include <sched.h>

int counter, producer_sleep_value;

int goalPerSecond = 1000;  // the number of cycles we want the producer function to run at in a second

int range = 0;

int delta_sleep_value = 1;

#define MAX_NUM_VALUES 5

int sampleArray[MAX_NUM_VALUES];

int totalValue;

int totalNumberOfValues;

int checkInterval = 1000*30; // in microseconds sets how often we check on the producer

float secondsPerCheckInterval;

int goalPerCheckInterval;

// Set some of the global variables

void init()

{

secondsPerCheckInterval = (float)checkInterval/(1000*1000);

goalPerCheckInterval = goalPerSecond*secondsPerCheckInterval;

producer_sleep_value = 1000;

}

// Obtain a sample count value and place it into the sampleArray

void inputSample(int new_value)

{

static int index;

totalNumberOfValues++;

totalValue += new_value;

sampleArray[index++] = new_value;

if (index >= MAX_NUM_VALUES) {

index = 0;

}

}

// Return the average value of all stored samples

float getAverageValue()

{

float total = 0;

for (int i = 0; i < MAX_NUM_VALUES; i++) {

total += sampleArray[i];

}

return total/MAX_NUM_VALUES;

}

// Return the average sample size over the last 30 seconds

float getTotalAverage()

{

int valuesPerTimeFrame;

float returnValue;

/* 1 value/checkInterval microseconds x 1,000,000 microseconds/second x 30 seconds = 1 * 1,000,000 * 30 / (checkInterval*1) = 

30,000,000/checkInterval

*/

valuesPerTimeFrame = 30000000/checkInterval;

// only last 30 seconds

if (totalNumberOfValues >= valuesPerTimeFrame) {

totalNumberOfValues = 0;

totalValue = 0;

printf("30 SECOND RESET ************\n");

}

if (totalNumberOfValues == 0) {

returnValue = 0;

} else {

returnValue = (float)totalValue/totalNumberOfValues;

}

return returnValue;

}

// Figure out how close we are to the goal

float getGoalPercent()

{

return getTotalAverage() * ((float)1/goalPerCheckInterval) * 100;

}

// Tries to maintain a consistent amount of output from the producer

void *consumerFunc(void *dummy)

{

while(1) {

inputSample(counter);

printf("current = %3d, current average: %3.2f, percent goal: %3.2f%c\n", counter, getAverageValue(), getGoalPercent(), '%');

        // If the produced amount is too low

if (counter+range < goalPerCheckInterval) {

producer_sleep_value -= delta_sleep_value;

printf("Reducing sleep value: %d\n", producer_sleep_value);

        // If the produced amount is too high

} else if (counter-range > goalPerCheckInterval) {

producer_sleep_value += delta_sleep_value;

printf("Increasing sleep value: %d\n", producer_sleep_value);

} 

counter = 0;

usleep(checkInterval);

}

}

// Produces the output we need

void *producerFunc(void *dummy)

{

while(1) {

counter++;

if (usleep(producer_sleep_value) != 0) 

printf("Problem detected with usleep!\n");

}

}

int main (int argc, const char * argv[]) {

init();

pthread_t consumerThread, producerThread;

pthread_create(&producerThread, NULL, producerFunc, NULL);

pthread_create(&consumerThread, NULL, consumerFunc, NULL);

pthread_join(producerThread, NULL);

pthread_join(consumerThread, NULL);

    return 0;

}