int main(int argc, char **argv)
{
clock_t tic = clock();
FILE *fp;
int i, choice, err;
long numBytes;
long Inpt= 0;
int rem = 0;
pid_t pid[NUM_THR_PROC];
struct primeArr *primeArray;
int object_size = 1024 * 1024 * 600;
sigset_t blockMask, origMask;
struct sigaction saIgnore, saOrigQuit, saOrigInt, saDefault;
printf("Please enter the max integer to search through for primes: ----> ");
scanf("%ld",&Inpt);
// derp(Inpt);
// Used this function to initially get my numbers into a BITMAP
// primeArray = crinit_primeArr(Inpt);
// IgnorePts(primeArray);
// p_primeArr(primeArray); //<<<-------------------------
// mapPrimes(primeArray->num, Inpt);
// freeArr(primeArray);
//The number of bytes we want to pull in
numBytes = Inpt / 4; //4 numbers are kept per char.
// printf("ERROR\n");
if (Inpt % 4 > 0) { numBytes++;}
// printf("ERROR\n");
unsigned char *myPrimes = malloc(sizeof(unsigned char*) * numBytes);
//char myPrimes[numBytes]; //So we get an array of that many chars(x4 numbers)
// printf("ERRORhelp\n");
//We open our bitmap(hashed in chars) and set it in the global list array
fp = fopen("bitMap", "r");
fread(List, sizeof(myPrimes[0]), numBytes, fp );
//printf("ERROR\n");
Inpt = numBytes / NUM_THR_PROC;
rem = numBytes % NUM_THR_PROC;
printf("Would you like to run threads or system? 1 for threads, 2 for system, anything else to quit");
scanf("%d",&choice);
//SIGNAL DEALING
sigemptyset(&blockMask); /* Block SIGCHLD */
sigaddset(&blockMask, SIGCHLD);
sigprocmask(SIG_BLOCK, &blockMask, &origMask);
saIgnore.sa_handler = SIG_IGN; /* Ignore SIGINT and SIGQUIT */
saIgnore.sa_flags = 0;
sigemptyset(&saIgnore.sa_mask);
sigaction(SIGINT, &saIgnore, &saOrigInt);
sigaction(SIGQUIT, &saIgnore, &saOrigQuit);
if(choice == 1)
runThreads(numBytes, Inpt, rem);
if(choice == 2)
{
void *myAddr = mount_shmem("/shProc", object_size);
myAddr = List;
for(i = 0; i < NUM_THR_PROC; i++)
{
for(i=0; i<NUM_THR_PROC; ++i)
{
d[i].Depth = numBytes;
int j = 0;
int k = 0;
d[i].offset = i;
d[i].sliceSt = (Inpt * i);
d[i].sliceEnd = Inpt * (i + 1);
//If it is our last fork or thread...
if(i == NUM_THR_PROC - 1)
{
d[i].sliceEnd = d[i].sliceEnd + rem;
}
}
}
for(i = 0; i < NUM_THR_PROC; i++)
{
switch(pid[i] = fork())
{
case -1:
fprintf(stderr, "Fork failed");
case 0: //child process
saDefault.sa_handler = SIG_DFL;
saDefault.sa_flags = 0;
sigemptyset(&saDefault.sa_mask);
if (saOrigInt.sa_handler != SIG_IGN)
sigaction(SIGINT, &saDefault, NULL);
if (saOrigQuit.sa_handler != SIG_IGN)
sigaction(SIGQUIT, &saDefault, NULL);
sigprocmask(SIG_SETMASK, &origMask, NULL);
printf("%d start: \n", d[i].sliceSt);
printf("%d end: \n", d->sliceEnd);
runSystem(d[i].sliceSt, d[i].sliceEnd, d[i].offset);
exit(EXIT_SUCCESS);
default:
break;
}
}
}
//Parse the char array and extract all happy primes with this FUNCtion.
mapTurnin(numBytes);
while(wait(NULL) != -1);
shm_unlink("/shProc");
clock_t toc = clock();
printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
if(argc != 5){
printf("[P or T] [# of P or T] [max prime] [print y/n] \n");
exit(EXIT_FAILURE);
}
char type = argv[1][0];
if(type != 'p' && type != 'P' && type != 't' && type != 'T'){
printf("invalid process type, need either p or t\n");
exit(EXIT_FAILURE);
}
int num = atoi(argv[2]);
if(num > 0)
num_proc = num;
else{
printf("invalid number of p/t\n");
exit(EXIT_FAILURE);
}
unsigned long max;
if((max = atol(argv[3])) > 0)
max_num = max;
else{
printf("invalid max number\n");
exit(EXIT_FAILURE);
}
char print;
if (argv[4][0] == 'y' || argv[4][0] == 'n') {
print = argv[4][0];
} else {
printf("Invalid entry for print primes.\n")
exit(EXIT_FAILURE);
}
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_handler = nevermore;
act.sa_flags = 0;
sigaction(SIGQUIT, &act, NULL);
sigaction(SIGINT, &act, NULL);
sigaction(SIGHUP, &act, NULL);
printf("hello progra\nm");
unsigned long primes_size = max_num / BITS_PER_WORD + 1;
printf("shouldn't be an error before here\n");
void *addr = mount_shmem(SHM_NAME, primes_size);
printf("memory is mounted");
primes = (unsigned char *) addr;
printf("primes did something I don't understand\n");
set_bitmap();
printf("bitmap is set");
seed_primes();
printf("primes are seeded");
fork();
printf("children have lived and died");
shm_unlink(SHM_NAME);
int pid = 0;
while((pid=wait(NULL))!= -1)
continue;
if(errno!=ECHILD)
perror("couldn't kill child processes");
free(process_array);
printf("everything has been freed");
return 0;
}
int main(int argc, char *argv[])
{
uint32_t i, j, k;
uint32_t m;
uint32_t byte, bit;
struct sigaction msa;
struct sigaction csa;
uint64_t object_size = BYTES + 1024*1024;
int opt;
/* child variables */
uint32_t nmult;
uint32_t mpert;
uint32_t temp;
uint32_t a;
uint32_t cbyte, cbit;
uint32_t start, end;
uint32_t prime;
if (argc < 2)
{
printf("Indicate the number of threads.\n");
exit(EXIT_FAILURE);
}
/* map shared memory object, allocate into it */
nproc = atoi(argv[1]);
if (nproc > MAX_PROC)
{
printf("The process limit is 8.\n");
exit(EXIT_FAILURE);
}
path = "/hari_primes";
pstruct = mount_shmem(path, object_size);
cfinder = (struct compFinder *) pstruct;
bzero(cfinder, sizeof(struct compFinder));
cfinder->nlist = (unsigned char *) (&cfinder[1]);
find = &cfinder->find[0];
complete = &cfinder->complete[0];
getid = (sem_t *) (&cfinder->nlist[BYTES]);
/* initialize composite finder struct and number list */
bzero(cfinder->nlist, BYTES);
cfinder->nproc = nproc;
/* initialize semaphores */
for (i = 0; i < nproc; i++)
{
sem_init(&find[i], 1, 0);
sem_init(&complete[i], 1, 0);
}
sem_init(getid, 1, 1);
/* install signal handler */
sigemptyset(&msa.sa_mask);
msa.sa_flags = 0;
msa.sa_handler = mhandler;
if (sigaction(SIGINT, &msa, NULL) == -1)
{
int j;
for (j = 0; j < cfinder->nproc; j++)
{
sem_destroy(&find[j]);
sem_destroy(&complete[j]);
}
sem_destroy(getid);
for (j = 0; j < nproc; j++)
wait(NULL);
if (shm_unlink(path) == -1)
{
perror("unlink shared memory\n");
exit(EXIT_FAILURE);
}
exit(EXIT_FAILURE);
}
/* initialize mask */
for (i = 0; i < 8; i++)
{
cfinder->mask[i] = 1 << (8-i-1);
}
cfinder->total = (uint32_t) ((unsigned long)(BYTES) * 8 - 1);
/* mark the number 1 as special */
cfinder->nlist[0] = cfinder->nlist[0] | cfinder->mask[1];
cfinder->done = 0;
/* create composite marking processes */
for (i = 0; i < nproc; i++)
{
switch(fork())
{
case -1:
for (j = 0; j < nproc; j++)
{
sem_destroy(&find[j]);
sem_destroy(&complete[j]);
}
sem_destroy(getid);
if (shm_unlink(path) == -1)
{
perror("unlink pstruct\n");
exit(EXIT_FAILURE);
perror("forking");
}
exit(EXIT_FAILURE);
break;
case 0: /* child */
/* install child signal handler */
sigemptyset(&csa.sa_mask);
csa.sa_flags = 0;
csa.sa_handler = chandler;
if (sigaction(SIGINT, &csa, NULL) == -1)
{
exit(EXIT_FAILURE);
}
/* get process number */
sem_wait(getid);
temp = cfinder->procNo;
cfinder->procNo++;
sem_post(getid);
/* wait for signal and get prime */
while(1)
{
sem_wait(&cfinder->find[temp]);
if (cfinder->done)
break;
prime = cfinder->prime;
nmult = cfinder->total / prime;
mpert = nmult / cfinder->nproc;
if (!mpert)
{
/* multiples per thread greater
than the number of threads */
for (a = 0; a < nmult - 1; a++)
{
if (temp == a)
{
start = (a + 2) * prime;
end = (a + 2) * prime;
}
}
for (a = nmult - 1; a < cfinder->nproc; a++)
{
/* for inactive threads
just make start
arbitrarily greater
than end */
if (temp == a)
{
start = 4;
end = 2;
}
}
}
else
{
/* set start composite number */
if (!temp)
start = 2 * prime;
else
{
start = (temp * mpert + 2) * prime;
/* set start to first
multiple in byte */
while (1)
{
if ( (start / 8) != ((start - prime) / 8))
{
/* first
multiple
in byte
*/
break;
}
start += prime;
}
}
/* set end composite number */
if (temp == (cfinder->nproc - 1))
{
end = nmult * prime;
}
else
{
end = ((temp + 1) * mpert + 1) * prime;
while(1)
{
/* set end to
last multiple
of byte */
if ( ((end + prime) / 8) != (end / 8))
{
/* last
multiple
of byte
*/
break;
}
end += prime;
}
}
}
for (a = start; a <= end; a += prime)
{
if (!(a % 2) && prime != 2)
{
if ( (cfinder->total - a) < prime)
break;
continue;
}
cbyte = a / 8;
cbit = a % 8;
cfinder->nlist[cbyte] = cfinder->nlist[cbyte] | cfinder->mask[cbit];
if ( (cfinder->total - a) < prime)
break;
}
sem_post(&cfinder->complete[temp]);
}
sem_post(&cfinder->complete[temp]);
/* happy/sad determination */
sem_wait(&cfinder->find[temp]);
if (cfinder->happy | cfinder->sad)
{
/* divide up list of numbers */
struct bag *hcheck = (struct bag *) malloc(sizeof(struct bag));
char buf[33];
if (!temp)
start = 0;
else
start = temp * (BYTES / cfinder->nproc);
if (temp == (cfinder->nproc - 1))
end = BYTES - 1;
else
end = (temp + 1) * (BYTES / cfinder->nproc) - 1;
/* iterate through prime numbers in region */
for (cbyte = start; cbyte <= end; cbyte++)
{
for (cbit = 0; cbit < 8; cbit++)
{
i = 8 * cbyte + cbit;
/* algorithm similar to that shown in
wikipedia page on happy/sad primes */
if (!(cfinder->nlist[cbyte] & cfinder->mask[cbit]))
{
prime = i;
initBag(hcheck);
addToBag(hcheck, 0);
while ((i > 1) && (!bagContains(hcheck,i)))
{
addToBag(hcheck, i);
sprintf(&buf[0], "%u", i);
i = calcInterm(&buf[0]);
}
if (i == 1 && cfinder->phappy)
{
printf("happy: %u\n", prime);
}
else if (i != 1 && cfinder->psad)
{
if (i) /* i != 0 */
printf("sad: %u\n", prime);
}
else {
}
freeBag(hcheck);
}
}
}
free(hcheck);
}
exit(EXIT_SUCCESS);
break;
default:
break;
}
}
/* perform sieve, mark off composites */
for (i = 2; i <= sqrt(cfinder->total);)
{
/* find first unmarked number */
j = i;
while(j < cfinder->total)
{
byte = j / 8;
bit = j % 8;
if (!(cfinder->nlist[byte] & cfinder->mask[bit]))
{
break;
}
j++;
}
if (j >= cfinder->total)
break;
cfinder->prime = j;
/* allowing threads now to cross off composites */
for(k = 0; k < nproc; k++)
sem_post(&find[k]);
/* waiting for all threads to finish before getting next prime
*/
for (k = 0; k < nproc; k++)
{
if (sem_wait(&complete[k])==-1)
perror("error\n");
}
i = ++j;
}
cfinder->done = 1;
/* telling processes to terminate */
for(k = 0; k < nproc; k++)
sem_post(&find[k]);
for (k = 0; k < nproc; k++)
sem_wait(&complete[k]);
/* check what to do next */
while ((opt = getopt(argc, argv, "phs")) == 'p')
{
printBitMap(cfinder, 1, cfinder->total);
}
/* set the proper flags */
while (opt != -1)
{
if (opt == 'h')
{
printf("happy primes will be found\n");
cfinder->happy = 1;
if (getopt(argc, argv, "phs") == 'p')
{
printf("happy primes will be printed \n");
cfinder->phappy = 1;
}
}
else if (opt == 's')
{
printf("sad primes will be found\n");
cfinder->sad = 1;
if (getopt(argc, argv, "phs") == 'p')
{
printf("sad primes will be printed\n");
cfinder->psad = 1;
}
}
else
{
printf("we're done \n");
}
opt = getopt(argc, argv, "phs");
}
/* start up processes again after setting flags */
for(k = 0; k < nproc; k++)
sem_post(&find[k]);
for (k = 0; k < nproc; k++)
wait(NULL);
/* destroy semaphores, delete shared memory object */
for (j = 0; j < nproc; j++)
{
sem_destroy(&find[j]);
sem_destroy(&complete[j]);
}
sem_destroy(getid);
if (shm_unlink(path) == -1)
{
perror("unlink pstruct\n");
exit(EXIT_FAILURE);
}
return 0;
}
