void eu065(char *ans) {
int N = 99;
mpz_t n, d, r;
mpz_init(n);
mpz_init(d);
mpz_init(r);
mpz_set_ui(n, eterm(N));
mpz_set_ui(d, 1);
for (int i = N-1; i >= 0; i--) {
mpz_swap(n, d);
int t = eterm(i);
mpz_addmul_ui(n, d, t);
mpz_gcd(r, n, d);
mpz_div(n, n, r);
mpz_div(d, d, r);
}
sprintf(ans, "%d", digitsum(n));
mpz_clear(r);
mpz_clear(d);
mpz_clear(n);
}
friend const BigInteger operator/(const BigInteger& left,
const BigInteger& right) {
BigInteger i;
assert(right != 0);
mpz_div(i.integer, left.integer, right.integer);
return i;
}
paillier_plaintext_t*
paillier_dec( paillier_plaintext_t* res,
paillier_pubkey_t* pub,
paillier_prvkey_t* prv,
paillier_ciphertext_t* ct )
{
if( !res )
{
res = (paillier_plaintext_t*) malloc(sizeof(paillier_plaintext_t));
mpz_init(res->m);
}
// mpz_out_str(stdout, 10, ct->c);
mpz_powm(res->m, ct->c, prv->lambda, pub->n_squared);
// printf("\ndecryption\n");
// mpz_out_str(stdout, 10, res->m);
mpz_sub_ui(res->m, res->m, 1);
// printf("\ndecryption\n");
// mpz_out_str(stdout, 10, res->m);
mpz_div(res->m, res->m, pub->n);
// printf("\ndecryption\n");
// mpz_out_str(stdout, 10, res->m);
mpz_mul(res->m, res->m, prv->x);
// printf("\ndecryption\n");
// mpz_out_str(stdout, 10, res->m);
//mpz_mod(res->m, res->m, pub->n);
// printf("\ndecryption\n");
// mpz_out_str(stdout, 10, res->m);
return res;
}
void
complete_prvkey( paillier_prvkey_t* prv, paillier_pubkey_t* pub )
{
mpz_powm(prv->x, pub->n_plusone, prv->lambda, pub->n_squared);
mpz_sub_ui(prv->x, prv->x, 1);
mpz_div(prv->x, prv->x, pub->n);
mpz_invert(prv->x, prv->x, pub->n);
}
VAL bigDiv(VM* vm, VAL x, VAL y) {
mpz_t* bigint;
VAL cl = allocate(vm, sizeof(ClosureType) + sizeof(void*));
bigint = allocate(vm, sizeof(mpz_t));
mpz_div(*bigint, GETMPZ(x), GETMPZ(y));
cl -> ty = BIGINT;
cl -> info.ptr = (void*)bigint;
return cl;
}
obj rational_to_bignum( obj a )
{
mpq_t a1;
mpz_t r;
OBJ_TO_MPQ(a1, a);
mpz_init(r);
mpz_div(r, mpq_numref(a1), mpq_denref(a1));
return mpz_to_bignum(r);
}
VAL bigDiv(VM* vm, VAL x, VAL y) {
mpz_t* bigint;
VAL cl = allocate(vm, sizeof(ClosureType) + sizeof(void*) +
sizeof(mpz_t), 0);
bigint = (mpz_t*)(((char*)cl) + sizeof(ClosureType) + sizeof(void*));
mpz_div(*bigint, GETMPZ(x), GETMPZ(y));
SETTY(cl, BIGINT);
cl -> info.ptr = (void*)bigint;
return cl;
}
obj bignum_div( obj a, obj b )
{
mpz_t r, a1, b1;
OBJ_TO_MPZ(a1, a);
OBJ_TO_MPZ(b1, b);
mpz_init(r);
if ( mpz_sgn(b1) == 0 ) {
scheme_error( "dividing ~s by zero", 1, a );
}
mpz_div(r, a1, b1);
return bignum_compact(r);
}
int prho(mpz_t factor1, mpz_t factor2, mpz_t n, long c, long maxIts)
/* It is assumed that the input is composite. */
{ static mpz_t a, b, oldA, oldB, tmp, tmp2;
static int initialized=0;
long i, its;
if (!(initialized)) {
mpz_init(a); mpz_init(b); mpz_init(tmp); mpz_init(tmp2);
mpz_init(oldA); mpz_init(oldB);
initialized=1;
}
if (c<1) c=1;
if (c>0x000000FF) c &= 0x000000FF;
mpz_set_ui(a, 1);
mpz_set_ui(b, 1);
its=0;
do {
mpz_set(oldA, a); mpz_set(oldB, b);
mpz_set_ui(tmp2, 1);
for (i=25; i>0; i--) {
mpz_mul(tmp, a, a); mpz_add_ui(tmp, tmp, c); mpz_mod(a, tmp, n);
mpz_mul(tmp, b, b); mpz_add_ui(tmp, tmp, c); mpz_mod(b, tmp, n);
mpz_mul(tmp, b, b); mpz_add_ui(tmp, tmp, c); mpz_mod(b, tmp, n);
mpz_sub(tmp, a, b); mpz_mul(tmp2, tmp2, tmp); mpz_mod(tmp2, tmp2, n);
}
its += 25;
mpz_gcd(tmp, tmp2, n);
} while ((mpz_cmp_ui(tmp, 1)==0) && (its<maxIts));
if (its >= maxIts) return -1;
if (mpz_cmp(tmp, n) == 0) {
mpz_set(a, oldA); mpz_set(b, oldB);
do {
mpz_mul(tmp, a, a); mpz_add_ui(tmp, tmp, c); mpz_mod(a, tmp, n);
mpz_mul(tmp, b, b); mpz_add_ui(tmp, tmp, c); mpz_mod(b, tmp, n);
mpz_mul(tmp, b, b); mpz_add_ui(tmp, tmp, c); mpz_mod(b, tmp, n);
mpz_sub(tmp, a, b);
mpz_gcd(tmp, tmp, n);
} while (mpz_cmp_ui(tmp, 1)==0);
}
if (mpz_cmp(tmp, n) < 0) {
mpz_set(factor1, tmp);
mpz_div(factor2, n, factor1);
return 0;
}
return -1; /* Unknown failure. */
}
/*
* \brief Encrypts/decrypts a message using the RSA algorithm.
*
* \param result a field to populate with the result of your RSA calculation.
* \param message the message to perform RSA on. (probably a cert in this case)
* \param d the encryption key from the key_file passed in through the
* command-line arguments
* \param n the modulus for RSA from the modulus_file passed in through
* the command-line arguments
*
* Fill in this function with your proj0 solution or see staff solutions.
*/
static void
perform_rsa(mpz_t result, mpz_t message, mpz_t d, mpz_t n)
{
int hex = 16;
mpz_t zero, one, two, tmp;
char zero_str[] = "0";
char one_str[] = "1";
char two_str[] = "2";
mpz_init(zero);
mpz_init(one);
mpz_init(two);
mpz_init(tmp);
mpz_set_str(zero, zero_str, hex);
mpz_set_str(one, one_str, hex);
mpz_set_str(two, two_str, hex);
mpz_set_str(tmp, zero_str, hex);
// initilize result = 1;
mpz_add(result, zero, one);
while (mpz_cmp(d, zero) > 0){
mpz_mod(tmp, d, two);
if (mpz_cmp(tmp, one) == 0) {
// result = (result * message) % n;
mpz_mul(tmp, result, message);
mpz_mod(result, tmp, n);
// d--;
mpz_sub(d, d, one);
}
// d = d/2;
mpz_div(d, d, two);
// message = (message * message) % n;
mpz_mul(tmp, message, message);
mpz_mod(message, tmp, n);
}
mpz_clear(zero);
mpz_clear(one);
mpz_clear(two);
mpz_clear(tmp);
}
/**
\brief 基b下整数n的长度
*/
void IntegerLength_BigBase(mpz_ptr r,mpz_ptr n,mpz_ptr b)
{
static mpz_t nn;
mpz_init(nn);
mpz_set(nn,n);
mpz_set_ui(r,0);
while(1)
{
if(mpz_size(nn)!=0)
{
mpz_add_ui(r,r,1);
mpz_div(nn,nn,b);
}
else
{
mpz_clear(nn);
return ;
}
}
}
paillier_plaintext_t*
paillier_dec( paillier_plaintext_t* res,
paillier_pubkey_t* pub,
paillier_prvkey_t* prv,
paillier_ciphertext_t* ct )
{
if( !res )
{
res = (paillier_plaintext_t*) malloc(sizeof(paillier_plaintext_t));
mpz_init(res->m);
}
mpz_powm(res->m, ct->c, prv->lambda, pub->n_squared);
mpz_sub_ui(res->m, res->m, 1);
mpz_div(res->m, res->m, pub->n);
mpz_mul(res->m, res->m, prv->x);
mpz_mod(res->m, res->m, pub->n);
return res;
}
BN BN::operator/(const BN& div) const
{
BN result;
mpz_div(PTR(result.dp), BNP, REF(div.dp));
return result;
}
int main(int argc, char** argv) {
FILE* ifp;
FILE* ofp;
char* nstr;
mpz_t e, d, n;
mpz_t p, q, t, phi;
mpz_t one, two;
mpz_t p2, q2;
int l1, l2;
l1 = 1;
clock();
mpz_init(e);
mpz_init(d);
mpz_init(n);
mpz_init(p);
mpz_init(q);
mpz_init(phi);
mpz_init(t);
mpz_init_set_si(one, 1);
mpz_init_set_si(two, 2);
mpz_init(p2);
mpz_init(q2);
if (argc != 3) {
printf("Bad command line.\n");
exit(1);
}
ifp = fopen(argv[1], "r");
ofp = fopen(argv[2], "w");
mpz_inp_str(e, ifp, 10);
mpz_inp_str(n, ifp, 10);
mpz_set(p, two);
while (true) {
nstr = mpz_get_str(NULL, 10, p);
l2 = strlen(nstr);
if (l2 > l1) {
printf("%d digits: %f seconds.\n", l1, clock() / ((double)CLOCKS_PER_SEC));
l1 = l2;
}
free((void*)nstr);
mpz_div(q, n, p);
mpz_mul(t, q, p);
if (mpz_cmp(t, n)==0)
break;
mpz_add(p, p, one);
}
mpz_sub(p2, p, one);
mpz_sub(q2, q, one);
mpz_mul(phi, p2, q2);
mpz_invert(d, e, phi);
mpz_out_str(ofp, 10, d);
fprintf(ofp, "\n\n");
mpz_out_str(ofp, 10, n);
return 0;
}
void damgard_jurik_function_l(mpz_t result ,mpz_t b, mpz_t n) {
mpz_sub_ui(result, b, 1);
mpz_div(result, result, n);
}
int shankSquares(mpz_t *n)
{
mpz_t myN, constA, constB, tmp, tmp2;
mpz_t Pi, Qi, Plast, Qlast, Qnext, bi;
long counter = 1;
int status = FAIL;
printf("[INFO ] Trying shank squares\n");
mpz_init_set(myN, *n);
mpz_init(tmp); mpz_init(tmp2);
mpz_init(bi); mpz_init(Qnext);
mpz_init(Pi);
mpz_mul_ui(tmp, myN, SHANKQUAREK); // constA = k*N
mpz_init_set(constA, tmp);
mpz_sqrt(tmp, constA); // constB = floor(sqrt(constA))
mpz_init_set(constB, tmp);
mpz_init_set(Plast, constB);
mpz_pow_ui(tmp, Plast, 2); // Qi = (constA) - (Pi**2)
mpz_sub(tmp, constA, tmp);
mpz_init_set(Qi, tmp);
mpz_init_set_ui(Qlast, 1);
while (counter < SHANKQUAREMAX)
{
mpz_add(tmp, constB, Plast); //bi = floor( (constB) + (Plast) / Qi )
mpz_fdiv_q(bi, tmp, Qi);
mpz_mul(tmp, bi, Qi); //Pi = (bi * Qi) - (Plast)
mpz_sub(Pi, tmp, Plast);
mpz_sub(tmp, Plast, Pi); //Qnext = Qlast + (bi * (Plast - Pi))
mpz_mul(tmp, tmp, bi);
mpz_add(Qnext, Qlast, tmp);
if (mpz_perfect_square_p(Qi) != 0 && counter % 2 == 0)
{
break;
}
else
{
mpz_set(Plast, Pi);
mpz_set(Qlast, Qi);
mpz_set(Qi, Qnext);
}
counter += 1;
}
mpz_sub(tmp, constB, Plast); //bi = floor( ( constB - Plast ) / sqrt(Qi) )
mpz_sqrt(tmp2, Qi);
mpz_fdiv_q(bi, tmp, tmp2);
mpz_sqrt(tmp, Qi); //Plast = (bi * sqrt(Qi)) + Plast
mpz_mul(tmp, tmp, bi);
mpz_add(Plast, tmp, Plast);
mpz_sqrt(Qlast, Qi);
mpz_pow_ui(tmp2, Plast, 2); //Qnext = ((constA) - Plast**2) / Qlast
mpz_sub(tmp, constA, tmp2);
mpz_div(Qnext, tmp, Qlast);
mpz_set(Qi, Qnext);
counter = 0;
while (counter < SHANKQUAREMAX)
{
mpz_add(tmp, constB, Plast); //bi = floor( ( constB + Plast ) / Qi )
mpz_fdiv_q(bi, tmp, Qi);
mpz_mul(tmp, bi, Qi); //Pi = (bi*Qi) - Plast
mpz_sub(Pi, tmp, Plast);
mpz_sub(tmp, Plast, Pi); //Qnext = Qlast + (bi * (Plast - Pi))
mpz_mul(tmp, tmp, bi);
mpz_add(Qnext, Qlast, tmp);
if (mpz_cmp(Pi, Plast) == 0)
{
break;
}
mpz_set(Plast, Pi);
mpz_set(Qlast, Qi);
mpz_set(Qi, Qnext);
counter += 1;
}
mpz_gcd(tmp, myN, Pi);
if (mpz_cmp_ui(tmp, 1) != 0 && mpz_cmp(tmp, myN) != 0)
{
printWin(&tmp, "Shanks squares");
status = WIN;
}
mpz_clear(myN); mpz_clear(constA);
mpz_clear(constB); mpz_clear(tmp); mpz_clear(tmp2);
mpz_clear(Pi); mpz_clear(Qi); mpz_clear(Plast);
mpz_clear(Qlast); mpz_clear(Qnext); mpz_clear(bi);
return status;
}
BigInteger &operator/=(const BigInteger &i) {
assert(i.integer != 0);
mpz_div(integer, integer, i.integer);
return *this;
}
static void derive_rsa_keys(MP_INT *n, MP_INT *e, MP_INT *d, MP_INT *u,
MP_INT *p, MP_INT *q,
unsigned int ebits)
{
MP_INT p_minus_1, q_minus_1, aux, phi, G, F;
assert(mpz_cmp(p, q) < 0);
mpz_init(&p_minus_1);
mpz_init(&q_minus_1);
mpz_init(&aux);
mpz_init(&phi);
mpz_init(&G);
mpz_init(&F);
/* Compute p-1 and q-1. */
mpz_sub_ui(&p_minus_1, p, 1);
mpz_sub_ui(&q_minus_1, q, 1);
/* phi = (p - 1) * (q - 1); the number of positive integers less than p*q
that are relatively prime to p*q. */
mpz_mul(&phi, &p_minus_1, &q_minus_1);
/* G is the number of "spare key sets" for a given modulus n. The smaller
G is, the better. The smallest G can get is 2. */
mpz_gcd(&G, &p_minus_1, &q_minus_1);
if (rsa_verbose)
{
if (mpz_cmp_ui(&G, 100) >= 0)
{
fprintf(stderr, "Warning: G=");
mpz_out_str(stdout, 10, &G);
fprintf(stderr, " is large (many spare key sets); key may be bad!\n");
}
}
/* F = phi / G; the number of relative prime numbers per spare key set. */
mpz_div(&F, &phi, &G);
/* Find a suitable e (the public exponent). */
mpz_set_ui(e, 1);
mpz_mul_2exp(e, e, ebits);
mpz_sub_ui(e, e, 1); /* make lowest bit 1, and substract 2. */
/* Keep adding 2 until it is relatively prime to (p-1)(q-1). */
do
{
mpz_add_ui(e, e, 2);
mpz_gcd(&aux, e, &phi);
}
while (mpz_cmp_ui(&aux, 1) != 0);
/* d is the multiplicative inverse of e, mod F. Could also be mod
(p-1)(q-1); however, we try to choose the smallest possible d. */
mpz_mod_inverse(d, e, &F);
/* u is the multiplicative inverse of p, mod q, if p < q. It is used
when doing private key RSA operations using the chinese remainder
theorem method. */
mpz_mod_inverse(u, p, q);
/* n = p * q (the public modulus). */
mpz_mul(n, p, q);
/* Clear auxiliary variables. */
mpz_clear(&p_minus_1);
mpz_clear(&q_minus_1);
mpz_clear(&aux);
mpz_clear(&phi);
mpz_clear(&G);
mpz_clear(&F);
}
bool BitcoinMiner2_mineProbableChain(primecoinBlock_t* block, mpz_class& mpzFixedMultiplier, bool& fNewBlock, unsigned int& nTriedMultiplier, unsigned int& nProbableChainLength,
unsigned int& nTests, unsigned int& nPrimesHit, sint32 threadIndex, mpz_class& mpzHash, unsigned int nPrimorialMultiplier)
{
mpz_class mpzChainOrigin;
mpz_class mpzFinalFixedMultiplier = mpzFixedMultiplier * mpzHash;
mpz_class mpzTemp;
uint32 nTime = GetTickCount();
cSieve_prepare(mpzFinalFixedMultiplier, block->nBits>>24);
nTime = GetTickCount()-nTime;
//printf("cSieve prep time: %d\n", nTime);
unsigned int nPrimorialSeq = 0;
while (vPrimes[nPrimorialSeq + 1] <= nPrimorialMultiplier)
nPrimorialSeq++;
// Allocate GMP variables for primality tests
CPrimalityTestParams testParams(block->nBits, nPrimorialSeq);
{
unsigned long lDivisor = 1;
unsigned int i;
testParams.vFastDivSeq.push_back(nPrimorialSeq);
for (i = 1; i <= nFastDivPrimes; i++)
{
// Multiply primes together until the result won't fit an unsigned long
if (lDivisor < ULONG_MAX / vPrimes[nPrimorialSeq + i])
lDivisor *= vPrimes[nPrimorialSeq + i];
else
{
testParams.vFastDivisors.push_back(lDivisor);
testParams.vFastDivSeq.push_back(nPrimorialSeq + i);
lDivisor = 1;
}
}
// Finish off by multiplying as many primes as possible
while (lDivisor < ULONG_MAX / vPrimes[nPrimorialSeq + i])
{
lDivisor *= vPrimes[nPrimorialSeq + i];
i++;
}
testParams.vFastDivisors.push_back(lDivisor);
testParams.vFastDivSeq.push_back(nPrimorialSeq + i);
testParams.nFastDivisorsSize = testParams.vFastDivisors.size();
}
// References to counters;
unsigned int& nChainLengthCunningham1 = testParams.nChainLengthCunningham1;
unsigned int& nChainLengthCunningham2 = testParams.nChainLengthCunningham2;
unsigned int& nChainLengthBiTwin = testParams.nChainLengthBiTwin;
uint32 debugStats_primes = 0;
uint32 debugStats_multipliersTested = 0;
while( block->serverData.blockHeight == jhMiner_getCurrentWorkBlockHeight(block->threadIndex) )
{
uint32 sieveFlags;
uint32 multiplier = cSieve_findNextMultiplier(&sieveFlags);
if( multiplier == 0 )
{
// mix in next layer
//printf("Layer finished [%d]\n", cSieve->currentSieveLayerIdx);
if( cSieve_sieveNextLayer() == false )
break;
mpzFinalFixedMultiplier = cSieve->mpzFixedMultiplier;
//printf("[%02d] debugStats_multipliersTested: %d\n", cSieve->currentSieveLayerIdx, debugStats_multipliersTested);
//printf("[%02d] debugStats_primes: %d\n", cSieve->currentSieveLayerIdx, debugStats_primes);
//double primality = (double)debugStats_primes / (double)debugStats_multipliersTested;
//printf("[%02d] debugStats_primality: %lf\n", cSieve->currentSieveLayerIdx, primality);
debugStats_primes = 0;
debugStats_multipliersTested = 0;
continue;
}
//// test for sieve bugs C1
//if( (sieveFlags&SIEVE_FLAG_C1_COMPOSITE)==0 && (rand()%10)==0 )
//{
// // test c1
// for(uint32 lt=0; lt<cSieve->chainLength; lt++)
// {
// uint32 aMult = 1<<lt;
// mpzChainOrigin = mpzFinalFixedMultiplier * multiplier * aMult - 1;
// for(uint32 f=0; f<cSieve->numPrimeFactors; f++)
// {
// uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]);
// if( mod == 0 )
// printf("c1 div by %d possible\n", vPrimes[f]);//__debugbreak();
// }
// }
//}
//// test for sieve bugs C2
//if( (sieveFlags&SIEVE_FLAG_C2_COMPOSITE)==0 && (rand()%10)==0 )
//{
// // test c1
// for(uint32 lt=0; lt<cSieve->chainLength; lt++)
// {
// uint32 aMult = 1<<lt;
// mpzChainOrigin = mpzFinalFixedMultiplier * multiplier * aMult + 1;
// for(uint32 f=0; f<cSieve->numPrimeFactors; f++)
// {
// uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]);
// if( mod == 0 )
// printf("c2 div by %d possible\n", vPrimes[f]);//__debugbreak();
// }
// }
//}
// test for sieve bugs BT
//if( (sieveFlags&SIEVE_FLAG_BT_COMPOSITE)==0 )
//{
// // test c1
// mpzChainOrigin = mpzFinalFixedMultiplier * multiplier + 1;
// for(uint32 f=0; f<cSieve->numPrimeFactors; f++)
// {
// uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]);
// if( mod == 0 )
// printf("bt-c2 div by %d possible\n", vPrimes[f]);
// }
// // test c2
// mpzChainOrigin = mpzFinalFixedMultiplier * multiplier - 1;
// for(uint32 f=0; f<cSieve->numPrimeFactors; f++)
// {
// uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]);
// if( mod == 0 )
// printf("bt-c2 div by %d possible\n", vPrimes[f]);
// }
//}
//mpzChainOrigin = mpzFinalFixedMultiplier * multiplier;
mpz_mul_ui(mpzChainOrigin.get_mpz_t(), mpzFinalFixedMultiplier.get_mpz_t(), multiplier);
nChainLengthCunningham1 = 0;
nChainLengthCunningham2 = 0;
nChainLengthBiTwin = 0;
bool canSubmitAsShare = ProbablePrimeChainTestFast2(mpzChainOrigin, testParams, sieveFlags, multiplier);
nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin);
if( nProbableChainLength >= 0x01000000 )
debugStats_primes++;
debugStats_multipliersTested++;
//bool canSubmitAsShare = ProbablePrimeChainTestFast(mpzChainOrigin, testParams);
//CBigNum bnChainOrigin;
//bnChainOrigin.SetHex(mpzChainOrigin.get_str(16));
//bool canSubmitAsShare = ProbablePrimeChainTestBN(bnChainOrigin, block->serverData.nBitsForShare, false, nChainLengthCunningham1, nChainLengthCunningham2, nChainLengthBiTwin);
if( nProbableChainLength >= 0x04000000 )
{
sint32 chainDif = (nProbableChainLength>>24) - 7;
primeStats.nChainHit += pow(8, (float)chainDif);
//primeStats.nChainHit += pow(8, ((float)((double)nProbableChainLength / (double)0x1000000))-7.0);
//primeStats.nChainHit += pow(8, floor((float)((double)nProbableChainLength / (double)0x1000000)) - 7);
nTests = 0;
primeStats.fourChainCount ++;
if (nProbableChainLength >= 0x5000000)
{
primeStats.fiveChainCount ++;
if (nProbableChainLength >= 0x6000000)
{
primeStats.sixChainCount ++;
if (nProbableChainLength >= 0x7000000)
primeStats.sevenChainCount ++;
}
}
}
//if( nBitsGen >= 0x03000000 )
// printf("%08X\n", nBitsGen);
primeStats.primeChainsFound++;
//if( nProbableChainLength > 0x03000000 )
// primeStats.qualityPrimesFound++;
if( nProbableChainLength > primeStats.bestPrimeChainDifficulty )
primeStats.bestPrimeChainDifficulty = nProbableChainLength;
if(nProbableChainLength >= block->serverData.nBitsForShare)
{
// note: mpzPrimeChainMultiplier does not include the blockHash multiplier
mpz_div(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzChainOrigin.get_mpz_t(), mpzHash.get_mpz_t());
//mpz_lsh(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzFixedMultiplier.get_mpz_t(), multiplier);
// update server data
block->serverData.client_shareBits = nProbableChainLength;
// generate block raw data
uint8 blockRawData[256] = {0};
memcpy(blockRawData, block, 80);
uint32 writeIndex = 80;
sint32 lengthBN = 0;
CBigNum bnPrimeChainMultiplier;
bnPrimeChainMultiplier.SetHex(block->mpzPrimeChainMultiplier.get_str(16));
std::vector<unsigned char> bnSerializeData = bnPrimeChainMultiplier.getvch();
lengthBN = bnSerializeData.size();
*(uint8*)(blockRawData+writeIndex) = (uint8)lengthBN; // varInt (we assume it always has a size low enough for 1 byte)
writeIndex += 1;
memcpy(blockRawData+writeIndex, &bnSerializeData[0], lengthBN);
writeIndex += lengthBN;
// switch endianness
for(uint32 f=0; f<256/4; f++)
{
*(uint32*)(blockRawData+f*4) = _swapEndianessU32(*(uint32*)(blockRawData+f*4));
}
time_t now = time(0);
struct tm * timeinfo;
timeinfo = localtime (&now);
char sNow [80];
strftime (sNow, 80, "%x - %X",timeinfo);
printf("%s - SHARE FOUND !!! (Th#: %u Multiplier: %d Layer: %d) --- DIFF: %f %s %s\n",
sNow, threadIndex, multiplier, cSieve->currentSieveLayerIdx, (float)((double)nProbableChainLength / (double)0x1000000),
nProbableChainLength >= 0x6000000 ? ">6":"", nProbableChainLength >= 0x7000000 ? ">7":"");
// submit this share
if (jhMiner_pushShare_primecoin(blockRawData, block))
primeStats.foundShareCount ++;
//printf("Probable prime chain found for block=%s!!\n Target: %s\n Length: (%s %s %s)\n", block.GetHash().GetHex().c_str(),TargetToString(block.nBits).c_str(), TargetToString(nChainLengthCunningham1).c_str(), TargetToString(nChainLengthCunningham2).c_str(), TargetToString(nChainLengthBiTwin).c_str());
//nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin);
// since we are using C structs here we have to make sure the memory for the CBigNum in the block is freed again
//delete *psieve;
//*psieve = NULL;
//block->bnPrimeChainMultiplier = NULL;
RtlZeroMemory(blockRawData, 256);
//delete *psieve;
//*psieve = NULL;
// dont quit if we find a share, there could be other shares in the remaining prime candidates
nTests = 0; // tehere is a good chance to find more shares so search a litle more.
//block->nonce++;
//return true;
//break;
//if (multipleShare)
}
}
/**
* entry point of the program.
*
* @function main
*
* @date 2016-01-15
*
* @revision none
*
* @designer Eric Tsang
*
* @programmer Eric Tsang
*
* @note
*
* sets up synchronization primitives, spawns worker threads, generates tasks
* for workers, receives results from workers, waits for workers to terminate,
* writes results to a file, and stdout.
*
* @signature int main(int argc,char** argv)
*
* @param argc number of command line arguments
* @param argv array of c strings of command line arguments
*
* @return status code.
*/
int main(int argc,char** argv)
{
// parse command line arguments
if (argc != 4)
{
fprintf(stderr,"usage: %s [integer] [path to log file] [num workers]\n",argv[0]);
return 1;
}
if(mpz_set_str(prime.value,argv[1],10) == -1)
{
fprintf(stderr,"usage: %s [integer] [path to log file] [num workers]\n",argv[0]);
return 1;
}
int logfile = open(argv[2],O_CREAT|O_WRONLY|O_APPEND);
FILE* logFileOut = fdopen(logfile,"w");
if(logfile == -1 || errno)
{
fprintf(stderr,"usage: %s [integer] [path to log file] [num workers]\nerror occurred: ",argv[0]);
perror(0);
return 1;
}
unsigned int numWorkers = atoi(argv[3]);
if (numWorkers <= 0)
{
fprintf(stderr,"usage: %s [integer] [path to log file] [num workers]\n num workers must be larger than or equal to 1",argv[0]);
return 1;
}
// set up synchronization primitives
for(register unsigned int i; i < numWorkers*MAX_PENDING_TASKS_PER_WORKER; ++i)
{
tasksNotFullSem.post();
}
// get start time
long startTime = current_timestamp();
// create the worker threads
std::vector<pthread_t> workers;
for(register unsigned int i = 0; i < numWorkers; ++i)
{
pthread_t worker;
pthread_create(&worker,0,worker_routine,0);
workers.push_back(worker);
}
// create tasks and place them into the tasks vector
{
Number prevPercentageComplete;
Number percentageComplete;
Number tempLoBound;
Number loBound;
for(mpz_set_ui(loBound.value,1);
mpz_cmp(loBound.value,prime.value) <= 0;
mpz_add_ui(loBound.value,loBound.value,MAX_NUMBERS_PER_TASK))
{
// calculate and print percentage complete
mpz_set(prevPercentageComplete.value,percentageComplete.value);
mpz_mul_ui(tempLoBound.value,loBound.value,100);
mpz_div(percentageComplete.value,tempLoBound.value,prime.value);
if(mpz_cmp(prevPercentageComplete.value,percentageComplete.value) != 0)
{
gmp_fprintf(stdout,"%Zd%\n",percentageComplete.value);
gmp_fprintf(logFileOut,"%Zd%\n",percentageComplete.value);
}
// insert the task into the task queue once there is room
Number* newNum = new Number();
mpz_set(newNum->value,loBound.value);
tasksNotFullSem.wait();
Lock scopelock(&taskAccess.sem);
tasks.push_back(newNum);
}
}
allTasksProduced = true;
// join all worker threads
for(register unsigned int i = 0; i < numWorkers; ++i)
{
void* unused;
pthread_join(workers[i],&unused);
}
// get end time
long endTime = current_timestamp();
// print out calculation results
std::sort(results.begin(),results.end(),[](Number* i,Number* j)
{
return mpz_cmp(i->value,j->value) < 0;
});
fprintf(stdout,"factors: ");
fprintf(logFileOut,"factors: ");
for(register unsigned int i = 0; i < results.size(); ++i)
{
gmp_fprintf(stdout,"%s%Zd",i?", ":"",results[i]->value);
gmp_fprintf(logFileOut,"%s%Zd",i?", ":"",results[i]->value);
delete results[i];
}
fprintf(stdout,"\n");
fprintf(logFileOut,"\n");
// print out execution results
fprintf(stdout,"total runtime: %lums\n",endTime-startTime);
fprintf(logFileOut,"total runtime: %lums\n",endTime-startTime);
// release system resources
fclose(logFileOut);
close(logfile);
return 0;
}
BN& BN::operator/=(const BN& div)
{
BN tmp(*this);
mpz_div(BNP, REF(tmp.dp), REF(div.dp));
return *this;
}
