int
ctx(int procs, int nprocs)
{
int msg;
int i;
int sum;
/*
* Main process - all others should be ready to roll, time the
* loop.
*/
for (i = 0; i < TRIPS; ++i) {
if (write(p[nprocs - procs][1], &msg, sizeof(msg)) !=
sizeof(msg)) {
if (errno) perror("read/write on pipe");
exit(1);
}
if (read(p[nprocs-1][0], &msg, sizeof(msg)) != sizeof(msg)) {
if (errno) perror("read/write on pipe");
exit(1);
}
sum = sumit(process_size);
}
return (sum);
}
// CONSTRUCTORS
explicit StatsReport(std::ofstream* aofp)
: os(*aofp) {
header();
sumit();
stars();
stages();
}
QString sumit_dir(const QString& path, const QString& temporary_path)
{
QStringList files = QDir(path).entryList(QStringList("*"), QDir::Files, QDir::Name);
QStringList dirs = QDir(path).entryList(QStringList("*"), QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
QString str = "";
for (int i = 0; i < dirs.count(); i++) {
str += QString("%1 %2\n").arg(sumit_dir(path + "/" + dirs[i], temporary_path)).arg(dirs[i]);
}
for (int i = 0; i < files.count(); i++) {
str += QString("%1 %2\n").arg(sumit(path + "/" + files[i], 0, temporary_path)).arg(files[i]);
}
return compute_the_string_hash(str);
}
void
doit(int p[][2], int rd, int wr)
{
int msg, sum = 0 /* lint */;
signal(SIGTERM, SIG_DFL);
if (data) bzero((void*)data, process_size);
for ( ;; ) {
if (read(p[rd][0], &msg, sizeof(msg)) != sizeof(msg)) {
if (errno) perror("read/write on pipe");
break;
}
sum = sumit(process_size);
if (write(p[wr][1], &msg, sizeof(msg)) != sizeof(msg)) {
if (errno) perror("read/write on pipe");
break;
}
}
use_int(sum);
exit(1);
}
int
main(int ac, char **av)
{
int i, max_procs;
double overhead = 0;
if (ac < 2) {
usage: printf("Usage: %s [-s kbytes] processes [processes ...]\n",
av[0]);
exit(1);
}
/*
* Need 4 byte ints.
*/
if (sizeof(int) != 4) {
fprintf(stderr, "Fix sumit() in ctx.c.\n");
exit(1);
}
/*
* If they specified a context size, get it.
*/
if (!strcmp(av[1], "-s")) {
if (ac < 4) {
goto usage;
}
process_size = atoi(av[2]) * 1024;
if (process_size > 0) {
data = (int *)calloc(1, max(process_size, CHUNK));
BENCHO(sumit(CHUNK), sumit(0), 0);
overhead = gettime();
overhead /= get_n();
overhead *= process_size;
overhead /= CHUNK;
}
ac -= 2;
av += 2;
}
#if defined(sgi) && defined(PIN)
ncpus = sysmp(MP_NPROCS);
sysmp(MP_MUSTRUN, 0);
#endif
for (max_procs = atoi(av[1]), i = 1; i < ac; ++i) {
int procs = atoi(av[i]);
if (max_procs < procs) max_procs = procs;
}
max_procs = create_pipes(p, max_procs);
overhead += pipe_cost(p, max_procs);
max_procs = create_daemons(p, pids, max_procs);
fprintf(stderr, "\n\"size=%dk ovr=%.2f\n", process_size/1024, overhead);
for (i = 1; i < ac; ++i) {
double time;
int procs = atoi(av[i]);
if (procs > max_procs) continue;
BENCH(ctx(procs, max_procs), 0);
time = usecs_spent();
time /= get_n();
time /= procs;
time /= TRIPS;
time -= overhead;
fprintf(stderr, "%d %.2f\n", procs, time);
}
/*
* Close the pipes and kill the children.
*/
killem(max_procs);
for (i = 0; i < max_procs; ++i) {
close(p[i][0]);
close(p[i][1]);
if (i > 0) {
wait(0);
}
}
return (0);
}
/*
* parse_args
*
* Parse command line arguments. Any errors cause the program to exit
* at this point.
*/
void parse_args(int argc, char *argv[])
{
int i;
int opt, errflag = 0;
int dflag = 0, bflag = 0, fflag = 0, tflag = 0;
extern int optind;
extern char *optarg;
/* DVAL: 0 1 2 3 4 5 6 7 8 9 10 11 */
int limits[] = { -1, -1, MAXBVAL, 17, 8, 5, 4, 3, 2, 2, 2, 2 };
while ((opt = getopt(argc, argv, "b:d:ft:D?")) != EOF) {
switch (opt) {
case 'b':
if (bflag)
errflag++;
else {
bflag++;
errno = 0;
BVAL = atoi(optarg);
if (errno) {
perror("atoi");
fprintf(stderr,
" ERROR : atoi - errno %d.",
errno);
errflag++;
}
}
break;
case 'd':
if (dflag)
errflag++;
else {
dflag++;
errno = 0;
DVAL = atoi(optarg);
if (errno) {
perror("atoi");
fprintf(stderr,
" ERROR : atoi - errno %d.",
errno);
errflag++;
}
}
break;
case 'f':
fflag = 1;
break;
case 'D':
AUSDEBUG = 1;
break;
case 't':
if (tflag)
errflag++;
else {
tflag++;
errno = 0;
TVAL = atoi(optarg);
if (!TVAL || errno) {
perror("atoi");
fprintf(stderr,
" ERROR : atoi - errno %d.",
errno);
errflag++;
}
}
break;
case '?':
errflag++;
break;
}
}
if (BVAL < 2) {
errflag++;
fprintf(stderr, "The value of b must be greater than 1\n");
} else if (DVAL < 2) {
errflag++;
fprintf(stderr, "The depth value must be greater than 1\n");
} else if (!fflag && (DVAL > MAXDVAL)) {
/* || BVAL > limits[DVAL])) { */
fprintf(stderr, "\tExceeded process creation limits. \
\n\tParameters will generate %lu processes. \n\tThe preset limits are as \
follows:\n\t\tdepth\tbreadth\ttotal\n", sumit(BVAL, DVAL));
for (i = 2; i <= MAXDVAL; i++)
fprintf(stderr, "\t\t %-3d\t %-5d\t%-5lu\n", i,
limits[i], sumit(limits[i], i));
exit(1);
}
main(int argc, char *argv[])
{
int sockfd, newsockfd, clilen, childpid;
struct sockaddr_in cli_addr, serv_addr;
int fd, orbfd;
time_t cur_time;
int PORT;
int con, c;
in_addr_t lna;
int val, lcv, lcv2, lcv3=0, high_fd;
struct timeval timeout;
char buffer[10002];
fd_set read_fds, except_fds;
for (lcv=0;lcv<NUM_CLIENTS;lcv++)
local_data.connected[lcv]=local_data.ipaddr[lcv]=local_data.used[lcv]=0;
strt.msgID = 2;
strt.msgSize = 8;
if (argc != 3) {
fprintf(stderr, "usage: %s port sourcename\n", argv[0]);
exit(1);
}
PORT=atoi(argv[1]);
printf("source name: %s\nport: %d\n",argv[2],PORT);
*((short int *)buffer)=htons(100);
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("revelle_data: can't open stream socket");
exit(-1);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
if (-1 != (lna=inet_addr("198.202.124.8")))
memcpy(&(serv_addr.sin_addr), &lna,
min(sizeof(serv_addr.sin_addr), sizeof(lna)));
else
{
perror("host lookup failed");
exit(-1);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))<0)
{
perror("connect failed!");
exit(-1);
}
while(1)
{
FD_ZERO(&read_fds);
FD_SET(sockfd,&read_fds);
high_fd=sockfd+1;
timeout.tv_sec=10;
timeout.tv_usec=0;
lcv=select(high_fd,&read_fds,0,0,&timeout);
if (lcv<0)
{
perror("select");
exit(-1);
}
else if (FD_ISSET(sockfd,&read_fds))
{
if (read(sockfd,buffer,2)<=0)
{
perror("read");
exit(-1);
}
printf(" * %d\n",*((short int*)buffer));
}
else
{
pkt.msgID=htons(1);
pkt.msgSize=htons(58);
pkt.seq_num=htonl(lcv3++);
pkt.timestamp=time(NULL);
pkt.num_chan=htons(2);
pkt.num_samp=htons(2);
pkt.samp_rate=1.0;
strncpy(pkt.sta_name,"PFO",5);
strncpy(pkt.net_name,"SM",2);
pkt.pad=0;
strncpy(buffer,"dus",3); /* channel */
strncpy(buffer+3,"N",2); /* location code */
*(buffer+4)=0; /* pad */
strncpy(buffer+6,"lon",3); /* channel */
strncpy(buffer+9,"S",2); /* location code */
*(buffer+11)=0; /* pad */
*((short int*)(buffer+12))=htons(1000);
*((short int*)(buffer+14))=htons(-1000);
*((short int*)(buffer+16))=htons(3);
*((short int*)(buffer+18))=htons(4);
/*pkt.chksum=htons(0);*/ /* use this to send invalid pkts */
pkt.chksum=htons(sumit((char*)&pkt,36,buffer,20));
printf("sent data checksum=%d, size of header=%d\n",ntohs(pkt.chksum),sizeof(pkt));
if (write(sockfd,&pkt,38)!=38)
{
printf("write issue!\n");
}
if (write(sockfd,buffer,20)!=20)
{
printf("write issue!2\n");
}
}
}
}
