/* * print all primes number from 2 to maxval using Sieve of Eratosthenes algorithm * @param: maxval with conditin that maxval is in range 2-2^24 * @output: print all prime numbers from 2 to maxval */ void primes(uint32_t maxval) { /* * Construct an array of uint32_t, and each bit of this array represent an integer from 2 to maxval to save space */ int arr_size = ceil_func((double)maxval/32, (int)maxval/32); uint32_t *se = malloc(arr_size*sizeof(uint32_t)); uint32_t *holder = malloc(sizeof(uint32_t)); //initialize all bits to 0 for(int k = 0; k < arr_size; k++) { se[k] = 0x00; } //Initialize byte and bit int byteTH = 0; int bitTH = 31; uint32_t p = 2; uint32_t j = 0; while (p*p <= maxval) { j = p*p; while (j <= maxval) { //Determine the byteTH and bitTH to be set based on j if (j < 8) { bitTH = 31-(int)j; byteTH = 0; } else { bitTH = 31 - ((int)j%32); byteTH = (int)j / 32; } //set all non-prime number bits to 1 se[byteTH] |= ((0x01) << bitTH); j += p; } //Continue to increment p until se[p] = 0 which means that it has not been marked as non-prime numbers in previous rounds p += 1; bitTH = 31 - ((int)p%32); byteTH = (int)p / 32; while((se[byteTH] & ((0x01) << bitTH)) != 0) { p += 1; //re-calculate bitTH and byteTH bitTH = 31 - ((int)p%32); byteTH = (int)p / 32; } } //First to print out the maxval value *holder = htonl(maxval); fwrite(holder, 1, sizeof(uint32_t), stdout); //Then go through the array se and print out the index of those bits that are NOT set //Note that we will start at 29th bit of the first uint32_t number in se array since the first 2 bits represent 0 and 1 byteTH = 0; bitTH = 29; uint32_t index = 2; while (index <= maxval) { if((se[byteTH] & ((0x01) << bitTH)) == 0) { *holder = htonl(index); fwrite(holder, 1, sizeof(uint32_t), stdout); } index += 1; bitTH -= 1; if(bitTH < 0) { byteTH += 1; bitTH = 31; } } free(holder); free(se); }
PIPE_ALIGN_STACK static boolean test_round(unsigned verbose, FILE *fp) { LLVMModuleRef module = NULL; LLVMValueRef test_round = NULL, test_trunc, test_floor, test_ceil; LLVMExecutionEngineRef engine = lp_build_engine; LLVMPassManagerRef pass = NULL; char *error = NULL; test_round_t round_func, trunc_func, floor_func, ceil_func; float unpacked[4]; unsigned packed; boolean success = TRUE; int i; module = LLVMModuleCreateWithName("test"); test_round = add_test(module, "round", lp_build_round); test_trunc = add_test(module, "trunc", lp_build_trunc); test_floor = add_test(module, "floor", lp_build_floor); test_ceil = add_test(module, "ceil", lp_build_ceil); if(LLVMVerifyModule(module, LLVMPrintMessageAction, &error)) { printf("LLVMVerifyModule: %s\n", error); LLVMDumpModule(module); abort(); } LLVMDisposeMessage(error); #if 0 pass = LLVMCreatePassManager(); LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass); /* These are the passes currently listed in llvm-c/Transforms/Scalar.h, * but there are more on SVN. */ LLVMAddConstantPropagationPass(pass); LLVMAddInstructionCombiningPass(pass); LLVMAddPromoteMemoryToRegisterPass(pass); LLVMAddGVNPass(pass); LLVMAddCFGSimplificationPass(pass); LLVMRunPassManager(pass, module); #else (void)pass; #endif round_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_round)); trunc_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_trunc)); floor_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_floor)); ceil_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_ceil)); memset(unpacked, 0, sizeof unpacked); packed = 0; if (0) LLVMDumpModule(module); for (i = 0; i < 3; i++) { v4sf xvals[3] = { {-10.0, -1, 0, 12.0}, {-1.5, -0.25, 1.25, 2.5}, {-0.99, -0.01, 0.01, 0.99} }; v4sf x = xvals[i]; v4sf y, ref; float *xp = (float *) &x; float *refp = (float *) &ref; printf("\n"); printv("x ", x); refp[0] = round(xp[0]); refp[1] = round(xp[1]); refp[2] = round(xp[2]); refp[3] = round(xp[3]); y = round_func(x); printv("C round(x) ", ref); printv("LLVM round(x)", y); compare(ref, y); refp[0] = trunc(xp[0]); refp[1] = trunc(xp[1]); refp[2] = trunc(xp[2]); refp[3] = trunc(xp[3]); y = trunc_func(x); printv("C trunc(x) ", ref); printv("LLVM trunc(x)", y); compare(ref, y); refp[0] = floor(xp[0]); refp[1] = floor(xp[1]); refp[2] = floor(xp[2]); refp[3] = floor(xp[3]); y = floor_func(x); printv("C floor(x) ", ref); printv("LLVM floor(x)", y); compare(ref, y); refp[0] = ceil(xp[0]); refp[1] = ceil(xp[1]); refp[2] = ceil(xp[2]); refp[3] = ceil(xp[3]); y = ceil_func(x); printv("C ceil(x) ", ref); printv("LLVM ceil(x) ", y); compare(ref, y); } LLVMFreeMachineCodeForFunction(engine, test_round); LLVMFreeMachineCodeForFunction(engine, test_trunc); LLVMFreeMachineCodeForFunction(engine, test_floor); LLVMFreeMachineCodeForFunction(engine, test_ceil); LLVMDisposeExecutionEngine(engine); if(pass) LLVMDisposePassManager(pass); return success; }
/* * rndsearch function to generate numbits-bit probable prime * @param: k numbits, maxitr, FILE pointer to primesfile, FILE pointer to rndfile * @output: Print out rndsearch process and generate a probable prime */ void rndsearch(int k, int maxitr, FILE *fp, FILE *fp_rndfile) { int byte = 0; int x_byte = ceil_func((double)k/8, (int)k/8); char *temp = malloc(x_byte); //read in x_byte from rndfile int itr_count = 1; while((byte = fread(temp, 1, x_byte, fp_rndfile)) > 0) { BIGNUM *bn_n = RndOddNum(k, temp, x_byte); if(bn_n == NULL) { free(temp); return; //ERROR has happened in RndOddNum() function call } else { //Print itr fprintf(stdout, "RANDOM-SEARCH: iteration %d\n", itr_count); itr_count += 1; fprintf(stdout, " n = %s\n", BN_bn2dec(bn_n)); //Use trial division function to check if n passes trial division test int trialdiv_returnCode = trialdiv(bn_n, fp, 2); //reset fp pointer to beginning of primesfile for next time use rewind(fp); if(trialdiv_returnCode == -1) { //error has happened in trialdiv function. Terminate this function free(temp); BN_free(bn_n); //free from RndOddNum() function call return; } else if(trialdiv_returnCode == 0) { BN_free(bn_n); continue; //bn_n does not pass trial division test. Continue to generate next number } int millerrabin_returnCode = millerrabin(bn_n, maxitr, fp, 2); //reset fp pointer to beginning of primesfile for next time use rewind(fp); if(millerrabin_returnCode == -1) { //error has happened in millerrabin function. Terminate this function free(temp); BN_free(bn_n); //free from RndOddNum() function call return; } else if(millerrabin_returnCode == 1) { free(temp); BN_free(bn_n); //free from RndOddNum() function call return; //Prove n to be a prime number. End function } else { //continue generate the next probable prime BN_free(bn_n); } } } //Free in case we have never generated a bn_n that passes both tests free(temp); fprintf(stderr, "Run out of bytes in rndfile and we have not successfully generated a prime number\n"); }