int
main(int argc, char **argv)
{
struct iperf_test *test;
// XXX: Setting the process affinity requires root on most systems.
// Is this a feature we really need?
#ifdef TEST_PROC_AFFINITY
/* didnt seem to work.... */
/*
* increasing the priority of the process to minimise packet generation
* delay
*/
int rc = setpriority(PRIO_PROCESS, 0, -15);
if (rc < 0) {
perror("setpriority:");
fprintf(stderr, "setting priority to valid level\n");
rc = setpriority(PRIO_PROCESS, 0, 0);
}
/* setting the affinity of the process */
cpu_set_t cpu_set;
int affinity = -1;
int ncores = 1;
sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set);
if (errno)
perror("couldn't get affinity:");
if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0)
err("sysconf: couldn't get _SC_NPROCESSORS_CONF");
CPU_ZERO(&cpu_set);
CPU_SET(affinity, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0)
err("couldn't change CPU affinity");
#endif
test = iperf_new_test();
if (!test)
iperf_errexit(NULL, "create new test error - %s", iperf_strerror(i_errno));
iperf_defaults(test); /* sets defaults */
if (iperf_parse_arguments(test, argc, argv) < 0) {
iperf_err(test, "parameter error - %s", iperf_strerror(i_errno));
fprintf(stderr, "\n");
usage_long();
exit(1);
}
if (run(test) < 0)
iperf_errexit(test, "error - %s", iperf_strerror(i_errno));
iperf_free_test(test);
return 0;
}
int
main(int argc, char **argv)
{
struct iperf_test *test;
// XXX: Setting the process affinity requires root on most systems.
// Is this a feature we really need?
#ifdef TEST_PROC_AFFINITY
/* didnt seem to work.... */
/*
* increasing the priority of the process to minimise packet generation
* delay
*/
int rc = setpriority(PRIO_PROCESS, 0, -15);
if (rc < 0) {
perror("setpriority:");
printf("setting priority to valid level\n");
rc = setpriority(PRIO_PROCESS, 0, 0);
}
/* setting the affinity of the process */
cpu_set_t cpu_set;
int affinity = -1;
int ncores = 1;
sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set);
if (errno)
perror("couldn't get affinity:");
if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0)
err("sysconf: couldn't get _SC_NPROCESSORS_CONF");
CPU_ZERO(&cpu_set);
CPU_SET(affinity, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0)
err("couldn't change CPU affinity");
#endif
test = iperf_new_test();
if (!test) {
iperf_error("create new test error");
exit(1);
}
iperf_defaults(test); /* sets defaults */
// XXX: Check signal for errors?
signal(SIGINT, sig_handler);
if (setjmp(env)) {
if (test->ctrl_sck >= 0) {
test->state = (test->role == 'c') ? CLIENT_TERMINATE : SERVER_TERMINATE;
if (Nwrite(test->ctrl_sck, &test->state, sizeof(char), Ptcp) < 0) {
i_errno = IESENDMESSAGE;
return (-1);
}
}
exit(1);
}
if (iperf_parse_arguments(test, argc, argv) < 0) {
iperf_error("parameter error");
fprintf(stderr, "\n");
usage_long();
exit(1);
}
if (iperf_run(test) < 0) {
iperf_error("error");
exit(1);
}
iperf_free_test(test);
printf("\niperf Done.\n");
return (0);
}
/*
parse_args()
Parse the command line arguments
*/
void
parse_args(int argc, char **argv, twolame_options * encopts )
{
int ch=0;
// process args
struct option longopts[] = {
// Input
{ "raw-input", no_argument, NULL, 'r' },
{ "byte-swap", no_argument, NULL, 'x' },
{ "samplerate", required_argument, NULL, 's' },
{ "channels", required_argument, NULL, 'N' },
{ "swap-channels", no_argument, NULL, 'g' },
{ "scale", required_argument, NULL, 1000 },
{ "scale-l", required_argument, NULL, 1001 },
{ "scale-r", required_argument, NULL, 1002 },
// Output
{ "mode", required_argument, NULL, 'm' },
{ "downmix", no_argument, NULL, 'a' },
{ "bitrate", required_argument, NULL, 'b' },
{ "psyc-mode", required_argument, NULL, 'P' },
{ "vbr", no_argument, NULL, 'v' },
{ "vbr-level", required_argument, NULL, 'V' },
{ "max-bitrate", required_argument, NULL, 'B' },
{ "ath", required_argument, NULL, 'l' },
{ "quick", required_argument, NULL, 'q' },
{ "single-frame", no_argument, NULL, 'S' },
// Misc
{ "copyright", no_argument, NULL, 'c' },
{ "non-original", no_argument, NULL, 'o' },
{ "original", no_argument, NULL, 1003 },
{ "protect", no_argument, NULL, 'p' },
{ "padding", no_argument, NULL, 'd' },
{ "reserve-bits", required_argument, NULL, 'R' },
{ "deemphasis", required_argument, NULL, 'e' },
{ "energy", no_argument, NULL, 'E' },
// Verbosity
{ "talkativity", required_argument, NULL, 't' },
{ "quiet", no_argument, NULL, 1004 },
{ "brief", no_argument, NULL, 1005 },
{ "verbose", no_argument, NULL, 1006 },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
// Create a short options structure from the long one
char* shortopts = build_shortopt_string( longopts );
//printf("shortopts: %s\n", shortopts);
while( (ch = getopt_long( argc, argv, shortopts, longopts, NULL )) != -1)
{
switch(ch) {
// Input
case 'r':
sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_PCM_16;
break;
case 'x':
byteswap = TRUE;
break;
case 's':
twolame_set_out_samplerate(encopts, atoi(optarg));
sfinfo.samplerate = atoi(optarg);
break;
case 'N':
sfinfo.channels = atoi(optarg);
break;
case 'g':
channelswap = TRUE;
break;
case 1000: // --scale
twolame_set_scale( encopts, atof(optarg) );
break;
case 1001: // --scale-l
twolame_set_scale_left( encopts, atof(optarg) );
break;
case 1002: // --scale-r
twolame_set_scale_right( encopts, atof(optarg) );
break;
// Output
case 'm':
if (*optarg == 's') {
twolame_set_mode(encopts, TWOLAME_STEREO);
} else if (*optarg == 'd') {
twolame_set_mode(encopts, TWOLAME_DUAL_CHANNEL);
} else if (*optarg == 'j') {
twolame_set_mode(encopts, TWOLAME_JOINT_STEREO);
} else if (*optarg == 'm') {
twolame_set_mode(encopts, TWOLAME_MONO);
} else if (*optarg == 'a') {
twolame_set_mode(encopts, TWOLAME_AUTO_MODE);
} else {
fprintf(stderr, "Error: mode must be a/s/d/j/m not '%s'\n\n", optarg);
usage_long();
}
break;
case 'a': // downmix
twolame_set_mode(encopts, TWOLAME_MONO);
break;
case 'b':
twolame_set_bitrate(encopts, atoi(optarg));
break;
case 'P':
twolame_set_psymodel(encopts, atoi(optarg));
break;
case 'v':
twolame_set_VBR(encopts, TRUE);
break;
case 'V':
twolame_set_VBR(encopts, TRUE);
twolame_set_VBR_level(encopts, atof(optarg));
break;
case 'B':
twolame_set_VBR_max_bitrate_kbps(encopts, atoi(optarg));
break;
case 'l':
twolame_set_ATH_level(encopts, atof(optarg));
break;
case 'q':
twolame_set_quick_mode(encopts, TRUE);
twolame_set_quick_count(encopts, atoi(optarg));
break;
case 'S':
single_frame_mode = TRUE;
break;
// Miscellaneous
case 'c':
twolame_set_copyright(encopts, TRUE);
break;
case 'o': // --non-original
twolame_set_original(encopts, FALSE);
break;
case 1003: // --original
twolame_set_original(encopts, TRUE);
break;
case 'p':
twolame_set_error_protection(encopts, TRUE);
break;
case 'd':
twolame_set_padding(encopts, TWOLAME_PAD_ALL);
break;
case 'R':
twolame_set_num_ancillary_bits(encopts, atoi(optarg));
break;
case 'e':
if (*optarg == 'n')
twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_N);
else if (*optarg == '5')
twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_5);
else if (*optarg == 'c')
twolame_set_emphasis(encopts, TWOLAME_EMPHASIS_C);
else {
fprintf(stderr, "Error: emphasis must be n/5/c not '%s'\n\n", optarg);
usage_long();
}
break;
case 'E':
twolame_set_energy_levels(encopts, TRUE);
break;
// Verbosity
case 't':
twolame_set_verbosity(encopts, atoi(optarg));
break;
case 1004: // --quiet
twolame_set_verbosity(encopts, 0);
break;
case 1005: // --brief
twolame_set_verbosity(encopts, 1);
break;
case 1006: // --verbose
twolame_set_verbosity(encopts, 4);
break;
case 'h':
usage_long();
break;
default:
usage_short();
break;
}
}
// Look for the input and output file names
argc -= optind;
argv += optind;
while( argc ) {
if (inputfilename[0] == '\0')
strncpy(inputfilename, *argv, MAX_NAME_SIZE);
else if (outputfilename[0] == '\0')
strncpy(outputfilename, *argv, MAX_NAME_SIZE);
else {
fprintf(stderr, "excess argument: %s\n", *argv);
usage_short();
}
argv++;
argc--;
}
// Check that we now have input and output file names ok
if ( inputfilename[0] == '\0') {
fprintf(stderr, "Missing input filename.\n");
usage_short();
}
if ( outputfilename[0] == '\0' && strcmp(inputfilename, "-")!=0 ) {
// Create output filename from the inputfilename
// and change the suffix
new_extension( inputfilename, OUTPUT_SUFFIX, outputfilename );
}
if ( outputfilename[0] == '\0') {
fprintf(stderr, "Missing output filename.\n");
usage_short();
}
}
int main(int argc, char **argv)
{
char verbosity = 0;
char *mphf_file = NULL;
const char *keys_file = NULL;
FILE *mphf_fd = stdout;
FILE *keys_fd;
cmph_uint32 nkeys = UINT_MAX;
cmph_uint32 i = 0;
cmph_t *mphf = NULL;
cmph_io_adapter_t *source;
while (1)
{
char ch = (char)getopt(argc, argv, "hVvk:m:");
if (ch == -1) break;
switch (ch)
{
case 'k':
{
char *endptr;
nkeys = (cmph_uint32) strtoul(optarg, &endptr, 10);
if(*endptr != 0) {
fprintf(stderr, "Invalid number of keys %s\n", optarg);
exit(1);
}
}
break;
case 'm':
mphf_file = strdup(optarg);
break;
case 'v':
++verbosity;
break;
case 'V':
printf("%s\n", VERSION);
return 0;
case 'h':
usage_long(argv[0]);
return 0;
default:
usage(argv[0]);
return 1;
}
}
if (optind != argc - 1)
{
usage(argv[0]);
return 1;
}
keys_file = argv[optind];
int ret = 0;
if (mphf_file == NULL)
{
mphf_file = (char *)malloc(strlen(keys_file) + 5);
memcpy(mphf_file, keys_file, strlen(keys_file));
memcpy(mphf_file + strlen(keys_file), ".mph\0", (size_t)5);
}
keys_fd = fopen(keys_file, "r");
if (keys_fd == NULL)
{
fprintf(stderr, "Unable to open file %s: %s\n", keys_file, strerror(errno));
return -1;
}
if(nkeys == UINT_MAX) source = cmph_io_nlfile_adapter(keys_fd);
else source = cmph_io_nlnkfile_adapter(keys_fd, nkeys);
cmph_uint8 * hashtable = NULL;
mphf_fd = fopen(mphf_file, "r");
if (mphf_fd == NULL)
{
fprintf(stderr, "Unable to open input file %s: %s\n", mphf_file, strerror(errno));
free(mphf_file);
return -1;
}
mphf = cmph_load(mphf_fd);
fclose(mphf_fd);
if (!mphf)
{
fprintf(stderr, "Unable to parser input file %s\n", mphf_file);
free(mphf_file);
return -1;
}
cmph_uint32 siz = cmph_size(mphf);
hashtable = (cmph_uint8*)malloc(siz*sizeof(cmph_uint8));
memset(hashtable, 0, (size_t)siz);
//check all keys
for (i = 0; i < source->nkeys; ++i)
{
cmph_uint32 h;
char *buf;
cmph_uint32 buflen = 0;
source->read(source->data, &buf, &buflen);
h = cmph_search(mphf, buf, buflen);
if (!(h < siz))
{
fprintf(stderr, "Unknown key %*s in the input.\n", buflen, buf);
ret = 1;
} else if(hashtable[h])
{
fprintf(stderr, "Duplicated or unknown key %*s in the input\n", buflen, buf);
ret = 1;
} else hashtable[h] = 1;
if (verbosity)
{
printf("%s -> %u\n", buf, h);
}
source->dispose(source->data, buf, buflen);
}
cmph_destroy(mphf);
free(hashtable);
fclose(keys_fd);
free(mphf_file);
cmph_io_nlfile_adapter_destroy(source);
return ret;
}
int main(int argc, char **argv)
{
cmph_uint32 verbosity = 0;
char generate = 0;
char *mphf_file = NULL;
FILE *mphf_fd = stdout;
const char *keys_file = NULL;
FILE *keys_fd;
cmph_uint32 nkeys = UINT_MAX;
cmph_uint32 seed = UINT_MAX;
CMPH_HASH *hashes = NULL;
cmph_uint32 nhashes = 0;
cmph_uint32 i;
CMPH_ALGO mph_algo = CMPH_CHM;
double c = 0;
cmph_config_t *config = NULL;
cmph_t *mphf = NULL;
char * tmp_dir = NULL;
cmph_io_adapter_t *source;
cmph_uint32 memory_availability = 0;
cmph_uint32 b = 0;
cmph_uint32 keys_per_bin = 1;
while (1)
{
char ch = (char)getopt(argc, argv, "hVvgc:k:a:M:b:t:f:m:d:s:");
if (ch == -1) break;
switch (ch)
{
case 's':
{
char *cptr;
seed = (cmph_uint32)strtoul(optarg, &cptr, 10);
if(*cptr != 0) {
fprintf(stderr, "Invalid seed %s\n", optarg);
exit(1);
}
}
break;
case 'c':
{
char *endptr;
c = strtod(optarg, &endptr);
if(*endptr != 0) {
fprintf(stderr, "Invalid c value %s\n", optarg);
exit(1);
}
}
break;
case 'g':
generate = 1;
break;
case 'k':
{
char *endptr;
nkeys = (cmph_uint32)strtoul(optarg, &endptr, 10);
if(*endptr != 0) {
fprintf(stderr, "Invalid number of keys %s\n", optarg);
exit(1);
}
}
break;
case 'm':
mphf_file = strdup(optarg);
break;
case 'd':
tmp_dir = strdup(optarg);
break;
case 'M':
{
char *cptr;
memory_availability = (cmph_uint32)strtoul(optarg, &cptr, 10);
if(*cptr != 0) {
fprintf(stderr, "Invalid memory availability %s\n", optarg);
exit(1);
}
}
break;
case 'b':
{
char *cptr;
b = (cmph_uint32)strtoul(optarg, &cptr, 10);
if(*cptr != 0) {
fprintf(stderr, "Parameter b was not found: %s\n", optarg);
exit(1);
}
}
break;
case 't':
{
char *cptr;
keys_per_bin = (cmph_uint32)strtoul(optarg, &cptr, 10);
if(*cptr != 0) {
fprintf(stderr, "Parameter t was not found: %s\n", optarg);
exit(1);
}
}
break;
case 'v':
++verbosity;
break;
case 'V':
printf("%s\n", VERSION);
return 0;
case 'h':
usage_long(argv[0]);
return 0;
case 'a':
{
char valid = 0;
for (i = 0; i < CMPH_COUNT; ++i)
{
if (strcmp(cmph_names[i], optarg) == 0)
{
mph_algo = (CMPH_ALGO)i;
valid = 1;
break;
}
}
if (!valid)
{
fprintf(stderr, "Invalid mph algorithm: %s. It is not available in version %s\n", optarg, VERSION);
return -1;
}
}
break;
case 'f':
{
char valid = 0;
for (i = 0; i < CMPH_HASH_COUNT; ++i)
{
if (strcmp(cmph_hash_names[i], optarg) == 0)
{
hashes = (CMPH_HASH *)realloc(hashes, sizeof(CMPH_HASH) * ( nhashes + 2 ));
hashes[nhashes] = (CMPH_HASH)i;
hashes[nhashes + 1] = CMPH_HASH_COUNT;
++nhashes;
valid = 1;
break;
}
}
if (!valid)
{
fprintf(stderr, "Invalid hash function: %s\n", optarg);
return -1;
}
}
break;
default:
usage(argv[0]);
return 1;
}
}
if (optind != argc - 1)
{
usage(argv[0]);
return 1;
}
keys_file = argv[optind];
if (seed == UINT_MAX) seed = (cmph_uint32)time(NULL);
srand(seed);
int ret = 0;
if (mphf_file == NULL)
{
mphf_file = (char *)malloc(strlen(keys_file) + 5);
memcpy(mphf_file, keys_file, strlen(keys_file));
memcpy(mphf_file + strlen(keys_file), ".mph\0", (size_t)5);
}
keys_fd = fopen(keys_file, "r");
if (keys_fd == NULL)
{
fprintf(stderr, "Unable to open file %s: %s\n", keys_file, strerror(errno));
return -1;
}
if (seed == UINT_MAX) seed = (cmph_uint32)time(NULL);
if(nkeys == UINT_MAX) source = cmph_io_nlfile_adapter(keys_fd);
else source = cmph_io_nlnkfile_adapter(keys_fd, nkeys);
if (generate)
{
//Create mphf
mphf_fd = fopen(mphf_file, "w");
config = cmph_config_new(source);
cmph_config_set_algo(config, mph_algo);
if (nhashes) cmph_config_set_hashfuncs(config, hashes);
cmph_config_set_verbosity(config, verbosity);
cmph_config_set_tmp_dir(config, (cmph_uint8 *) tmp_dir);
cmph_config_set_mphf_fd(config, mphf_fd);
cmph_config_set_memory_availability(config, memory_availability);
cmph_config_set_b(config, b);
cmph_config_set_keys_per_bin(config, keys_per_bin);
//if((mph_algo == CMPH_BMZ || mph_algo == CMPH_BRZ) && c >= 2.0) c=1.15;
if(mph_algo == CMPH_BMZ && c >= 2.0) c=1.15;
if (c != 0) cmph_config_set_graphsize(config, c);
mphf = cmph_new(config);
cmph_config_destroy(config);
if (mphf == NULL)
{
fprintf(stderr, "Unable to create minimum perfect hashing function\n");
//cmph_config_destroy(config);
free(mphf_file);
return -1;
}
if (mphf_fd == NULL)
{
fprintf(stderr, "Unable to open output file %s: %s\n", mphf_file, strerror(errno));
free(mphf_file);
return -1;
}
cmph_dump(mphf, mphf_fd);
cmph_destroy(mphf);
fclose(mphf_fd);
}
else
{
cmph_uint8 * hashtable = NULL;
mphf_fd = fopen(mphf_file, "r");
if (mphf_fd == NULL)
{
fprintf(stderr, "Unable to open input file %s: %s\n", mphf_file, strerror(errno));
free(mphf_file);
return -1;
}
mphf = cmph_load(mphf_fd);
fclose(mphf_fd);
if (!mphf)
{
fprintf(stderr, "Unable to parser input file %s\n", mphf_file);
free(mphf_file);
return -1;
}
cmph_uint32 siz = cmph_size(mphf);
hashtable = (cmph_uint8*)calloc(siz, sizeof(cmph_uint8));
memset(hashtable, 0,(size_t) siz);
//check all keys
for (i = 0; i < source->nkeys; ++i)
{
cmph_uint32 h;
char *buf;
cmph_uint32 buflen = 0;
source->read(source->data, &buf, &buflen);
h = cmph_search(mphf, buf, buflen);
if (!(h < siz))
{
fprintf(stderr, "Unknown key %*s in the input.\n", buflen, buf);
ret = 1;
} else if(hashtable[h] >= keys_per_bin)
{
fprintf(stderr, "More than %u keys were mapped to bin %u\n", keys_per_bin, h);
fprintf(stderr, "Duplicated or unknown key %*s in the input\n", buflen, buf);
ret = 1;
} else hashtable[h]++;
if (verbosity)
{
printf("%s -> %u\n", buf, h);
}
source->dispose(source->data, buf, buflen);
}
cmph_destroy(mphf);
free(hashtable);
}
fclose(keys_fd);
free(mphf_file);
free(tmp_dir);
cmph_io_nlfile_adapter_destroy(source);
return ret;
}
