int main(int argc, char *argv[]) {
struct timespec start, end;
int sz = 0, *data = NULL;
switch (argc) {
case 2:
printf("Generating %d numbers\n", sz = atoi(argv[1]));
clock_gettime(CLOCK_MONOTONIC, &start);
data = alloc_random_data(sz);
print_data("allocated", data, sz);
clock_gettime(CLOCK_MONOTONIC, &end);
printf("Generating took %ld usecs\n", timespec_diff_us(&start, &end));
break;
default:
printf("Bad input arguments!\n");
exit(-1);
}
printf("Computing median...\n");
clock_gettime(CLOCK_MONOTONIC, &start);
int median = find_median(data, 0, sz-1, sz);
clock_gettime(CLOCK_MONOTONIC, &end);
free(data);
printf("Median = %d\n", median);
printf("Running time = %ld usecs\n", timespec_diff_us(&start, &end));
return 0;
}
static int amd_fam14h_stop(void)
{
int num, cpu;
struct timespec end_time;
clock_gettime(CLOCK_REALTIME, &end_time);
for (num = 0; num < AMD_FAM14H_STATE_NUM; num++) {
for (cpu = 0; cpu < cpu_count; cpu++)
amd_fam14h_disable(&amd_fam14h_cstates[num], cpu);
}
#ifdef DEBUG
clock_gettime(CLOCK_REALTIME, &dbg_time);
dbg_timediff = timespec_diff_us(end_time, dbg_time);
dprint("Disabling counters took: %lu ns\n", dbg_timediff);
#endif
timediff = timespec_diff_us(start_time, end_time);
if (timediff / 1000 > OVERFLOW_MS)
print_overflow_err((unsigned int)timediff / 1000000,
OVERFLOW_MS / 1000);
return 0;
}
static int amd_fam14h_start(void)
{
int num, cpu;
clock_gettime(CLOCK_REALTIME, &start_time);
for (num = 0; num < AMD_FAM14H_STATE_NUM; num++) {
for (cpu = 0; cpu < cpu_count; cpu++)
amd_fam14h_init(&amd_fam14h_cstates[num], cpu);
}
#ifdef DEBUG
clock_gettime(CLOCK_REALTIME, &dbg_time);
dbg_timediff = timespec_diff_us(start_time, dbg_time);
dprint("Enabling counters took: %lu us\n",
dbg_timediff);
#endif
return 0;
}
static int cpuidle_stop(void)
{
int cpu, state;
struct timespec end_time;
clock_gettime(CLOCK_REALTIME, &end_time);
timediff = timespec_diff_us(start_time, end_time);
for (cpu = 0; cpu < cpu_count; cpu++) {
for (state = 0; state < cpuidle_sysfs_monitor.hw_states_num;
state++) {
current_count[cpu][state] =
sysfs_get_idlestate_time(cpu, state);
dprint("CPU %d - State: %d - Val: %llu\n",
cpu, state, previous_count[cpu][state]);
}
};
return 0;
}
static bool write_data(struct a2dp_stream_out *out, const void *buffer,
size_t bytes)
{
struct audio_endpoint *ep = out->ep;
struct media_packet *mp = (struct media_packet *) ep->mp;
struct media_packet_rtp *mp_rtp = (struct media_packet_rtp *) ep->mp;
size_t free_space = ep->mp_data_len;
size_t consumed = 0;
while (consumed < bytes) {
size_t written = 0;
ssize_t read;
uint32_t samples;
int ret;
struct timespec current;
uint64_t audio_sent, audio_passed;
bool do_write = false;
/*
* prepare media packet in advance so we don't waste time after
* wakeup
*/
if (ep->codec->use_rtp) {
mp_rtp->hdr.sequence_number = htons(ep->seq++);
mp_rtp->hdr.timestamp = htonl(ep->samples);
}
read = ep->codec->encode_mediapacket(ep->codec_data,
buffer + consumed,
bytes - consumed, mp,
free_space, &written);
/*
* not much we can do here, let's just ignore remaining
* data and continue
*/
if (read <= 0)
return true;
/* calculate where are we and where we should be */
clock_gettime(CLOCK_MONOTONIC, ¤t);
if (!ep->samples)
memcpy(&ep->start, ¤t, sizeof(ep->start));
audio_sent = ep->samples * 1000000ll / out->cfg.rate;
audio_passed = timespec_diff_us(¤t, &ep->start);
/*
* if we're ahead of stream then wait for next write point,
* if we're lagging more than 100ms then stop writing and just
* skip data until we're back in sync
*/
if (audio_sent > audio_passed) {
struct timespec anchor;
ep->resync = false;
timespec_add(&ep->start, audio_sent, &anchor);
while (true) {
ret = clock_nanosleep(CLOCK_MONOTONIC,
TIMER_ABSTIME, &anchor,
NULL);
if (!ret)
break;
if (ret != EINTR) {
error("clock_nanosleep failed (%d)",
ret);
return false;
}
}
} else if (!ep->resync) {
uint64_t diff = audio_passed - audio_sent;
if (diff > MAX_DELAY) {
warn("lag is %jums, resyncing", diff / 1000);
ep->codec->update_qos(ep->codec_data,
QOS_POLICY_DECREASE);
ep->resync = true;
}
}
/* we send data only in case codec encoded some data, i.e. some
* codecs do internal buffering and output data only if full
* frame can be encoded
* in resync mode we'll just drop mediapackets
*/
if (written > 0 && !ep->resync) {
/* wait some time for socket to be ready for write,
* but we'll just skip writing data if timeout occurs
*/
if (!wait_for_endpoint(ep, &do_write))
return false;
if (do_write) {
if (ep->codec->use_rtp)
written += sizeof(struct rtp_header);
if (!write_to_endpoint(ep, written))
return false;
}
}
/*
* AudioFlinger provides 16bit PCM, so sample size is 2 bytes
* multiplied by number of channels. Number of channels is
* simply number of bits set in channels mask.
*/
samples = read / (2 * popcount(out->cfg.channels));
ep->samples += samples;
consumed += read;
}
return true;
}
