int main( int argc, char *argv[] )
{
benchmarks_t *bm = NULL;
enum bm_type_t bmt;
bmt = ia32_cpu_type();
switch (bmt) {
case BMT_P4:
printf( "Pentium 4 detected, enabling P4 performance monitoring.\n" );
bm = &p4_benchmarks;
break;
case BMT_K8:
printf( "AMD K8 detected, enabling K8 performance monitoring.\n" );
bm = &k8_benchmarks;
break;
default:
printf( "Unknown CPU type, performance monitoring disabled\n" );
}
perfmon_start(bm);
if( argc > 1 )
system( argv[1] );
perfmon_stop(bm);
perfmon_print(bm);
return 0;
}
int main( int argc, char *argv[] )
{
enum bm_type_t bmt;
unsigned total_time = 60, sample_period = 20;
unsigned int i;
bmt = ia32_cpu_type();
switch (bmt) {
case BMT_P4:
printf( "Pentium 4 detected, enabling P4 performance monitoring.\n" );
bm = &p4_benchmarks;
break;
case BMT_K8:
printf( "AMD K8 detected, enabling K8 performance monitoring.\n" );
bm = &k8_benchmarks;
break;
default:
printf( "Unknown CPU type, performance monitoring disabled\n" );
}
if( argc > 1 )
sscanf( argv[1], "%u", &sample_period );
if( argc > 2 )
sscanf( argv[2], "%u", &total_time );
if( signal(SIGINT, sigint_handler) == SIG_ERR ) {
printf( "Error installing the signal handler.\n" );
exit( 1 );
}
tot_samples = total_time / sample_period;
sample_width = bm->size + 1;
samples = malloc( sizeof(unsigned long long) * sample_width * tot_samples );
if( samples == NULL ) {
printf( "Error allocating memory.\n" );
exit( 1 );
}
for( next_sample = 0; next_sample < tot_samples; next_sample++ )
{
perfmon_start(bm);
sleep( sample_period );
perfmon_stop(bm);
samples[next_sample*sample_width + 0] = bm->tsc;
for( i = 0; i < bm->size; i++ )
samples[next_sample*sample_width + 1 + i] = bm->benchmarks[i].counter;
}
signal( SIGINT, SIG_DFL );
dumper();
return 0;
}
/**
* opd_do_read - enter processing loop
* @param buf buffer to read into
* @param size size of buffer
*
* Read some of a buffer from the device and process
* the contents.
*/
static void opd_do_read(char * buf, size_t size)
{
opd_open_pipe();
while (1) {
ssize_t count = -1;
/* loop to handle EINTR */
while (count < 0) {
count = op_read_device(devfd, buf, size);
/* we can lose an alarm or a hup but
* we don't care.
*/
if (signal_alarm) {
signal_alarm = 0;
opd_alarm();
}
if (signal_hup) {
signal_hup = 0;
opd_sighup();
}
if (signal_term)
opd_sigterm();
if (signal_child)
opd_sigchild();
if (signal_usr1) {
signal_usr1 = 0;
perfmon_start();
}
if (signal_usr2) {
signal_usr2 = 0;
perfmon_stop();
}
if (is_jitconv_requested()) {
verbprintf(vmisc, "Start opjitconv was triggered\n");
opd_do_jitdumps();
}
}
opd_do_samples(buf, count);
}
opd_close_pipe();
}
/**
* opd_do_read - enter processing loop
* @param buf buffer to read into
* @param size size of buffer
*
* Read some of a buffer from the device and process
* the contents.
*/
static void opd_do_read(char * buf, size_t size)
{
while (1) {
ssize_t count = -1;
/* loop to handle EINTR */
while (count < 0) {
count = op_read_device(devfd, buf, size);
/* we can lose an alarm or a hup but
* we don't care.
*/
if (signal_alarm) {
signal_alarm = 0;
opd_alarm();
}
if (signal_hup) {
signal_hup = 0;
opd_sighup();
}
if (signal_term)
opd_sigterm();
if (signal_usr1) {
signal_usr1 = 0;
perfmon_start();
}
if (signal_usr2) {
signal_usr2 = 0;
perfmon_stop();
}
}
opd_do_samples(buf, count);
}
}
int main( int argc, char *argv[] )
{
int dev_fd;
char *device_name;
char *buffer = (char *)((unsigned long)(buffer_space + MAX_BLOCK_SIZE) & MAX_BLOCK_MASK);
unsigned long device_size;
unsigned block_size, block_count, block;
int err, i;
benchmarks_t *bm;
if( argc < 2 )
usage(argv[0]);
device_name = argv[1];
// Init the performance counters.
bm = perfmon_arch_init();
if( NULL == bm )
exit( 1 );
// Open the device with *raw* access.
dev_fd = open( device_name, O_RDWR | O_DIRECT, 0 );
if( dev_fd == -1 ) {
fprintf( stderr, "Unable to open '%s': %s.\n",
device_name, strerror(errno) );
exit( 1 );
}
// Choose the number of blocks we want.
device_size = 1UL*1024UL*1024UL*1024UL;
block_count = device_size / (MAX_BLOCK_SIZE * MAX_IOVEC);
// Init the iovec array.
for( i = 0; i < MAX_IOVEC; i++ )
iovec[i].iov_base = buffer;
// Print the headers.
printf( "type,syscalls,block_size,iovecs," );
perfmon_print_headers(bm);
fflush(stdout);
// Perform the read experiment.
for( block_size = MIN_BLOCK_SIZE; block_size <= MAX_BLOCK_SIZE; block_size *= 2 )
{
if( lseek(dev_fd, 0, SEEK_SET) != 0 ) {
fprintf( stderr, "Seek error on '%s': %s.\n",
device_name, strerror(errno) );
exit( 1 );
}
for( i = 0; i < MAX_IOVEC; i++ )
iovec[i].iov_len = block_size;
block_count = device_size / (block_size * MAX_IOVEC);
printf( "read,%lu,%u,%u,", block_count, block_size, MAX_IOVEC );
fflush(stdout);
perfmon_start(bm);
for( block = 0; block < block_count; block++ )
{
err = readv(dev_fd, iovec, MAX_IOVEC);
if( err < 0 ) {
fprintf( stderr, "Read error on '%s': %s.\n",
device_name, strerror(errno) );
exit( 1 );
}
}
perfmon_stop(bm);
perfmon_print_data(bm);
}
// Perform the write experiment.
for( block_size = MIN_BLOCK_SIZE; block_size <= MAX_BLOCK_SIZE; block_size *= 2 )
{
if( lseek(dev_fd, 0, SEEK_SET) != 0 ) {
fprintf( stderr, "Seek error on '%s': %s.\n",
device_name, strerror(errno) );
exit( 1 );
}
for( i = 0; i < MAX_IOVEC; i++ )
iovec[i].iov_len = block_size;
block_count = device_size / (block_size * MAX_IOVEC);
printf( "write,%lu,%u,%u,", block_count, block_size, MAX_IOVEC );
fflush(stdout);
perfmon_start(bm);
for( block = 0; block < block_count; block++ )
{
err = writev(dev_fd, iovec, MAX_IOVEC);
if( err < 0 ) {
fprintf( stderr, "Write error on '%s': %s.\n",
device_name, strerror(errno) );
exit( 1 );
}
}
perfmon_stop(bm);
perfmon_print_data(bm);
}
close( dev_fd );
}
