Topic: [Closed] [Bounty] Primecoin Standalone CPU Miner Current: 3.5BTC (Read 13917 times)

Is this up yet? I'll create a poolers CPU miner fork for Primecoin if it is

apologies, just trying to help

When I put up the bounty I was more expecting BFGminer, native linux support would be awesome.

in the Op:


So you want a little bit your way for a miner we already knew and didn't contribute anything too? 

also there are these, just came out like yesterday

v0.2.1.1 - 7/18/2013
freeze bug fixed
added slight performance tweaks
http://test.dsync.net/jhPrimeminer-0.2.1.1.zip - x64 build

http://test.dsync.net/jhPrimeminer-0.2.1.1_x86.zip - x86 build

and of course the creator(s) should be paid, but a little bit my way for helping you guys sounds fair too doesn't it

you'd have tobe the creator to claim it  
If anything it should go to mikaelh for all his work on the high performace mods he's made too the orginal source

https://github.com/jh000/jhPrimeminer

1Jh1ejB8RDJowzW2fuqyjGzqHAjQ5fXEyb

something i found

Another valid point

i dont know if it performs same or better..

Forgot about this thread, xD!

Anyhow, ypool, from what I understand, does have a stand-alone miner. However, since their code won't work as-is on linux, and many people are doubting their authenticity, I am holding the coinage for now. However, this is a community bounty, so if the majority of people want me to send the coins to ypool, I'm cool with that.

I add 1 BTC to this bounty
'pledge' = 1 BTC

How does it beat the problem? I think having difficulty one less does not solve it: a miner optimized for the sub blockchain could generate valid blocks which would not pass the sieve if they were working on the main chain. This means they get payed for work easier that what they should be doing, "stealing" from honest miners in the same pool. I guess that if all miners did this "cheat" the problem wouldn't be that serious, however lot's of hardware would be doing "useless" work, something that we were trying to avoid. this gets worse as the difference between the main chain's difficulty and the pool's difficulty gets higher.

CUMP only implements addition, subtraction and multiplication... doesn't implement mpz_powm which is needed for the primality tests.  There's a ton of efficiencies that can be obtained just from optimizing the existing code, and without even trying to re-implement modular exponentialization in CUDA.

Will

Far from enough hints  

People from Tsukuba University already implemented GMP on CUDA:
http://www.hpcs.cs.tsukuba.ac.jp/~nakayama/cump/index.php?The%20CUDA%20Multiple%20Precision%20Arithmetic%20Library

If someone wants to roll his own implementation here's where he can start:
http://individual.utoronto.ca/haojunliu/courses/ECE1724_Report.pdf

If somebody already implemented primecoin client on GPU he should not have that advantage for too long or he can kill a coin mining. From some comparisons I've seen advantage can be even bigger than in BTC case.

This is spot on.   Both luke-jr and I have both had success replacing Openssl's default big number exponentiation function with the one from GMP.  I recommend perhaps people look there

That's enough hints for now!

Will

Unless I'm mistaken, the source code links on that page are dead ends.  Also, unless I'm mistaken, it is using a different algorithm and is running on smaller numbers.  A useful thing to find would be a CUDA (or, ideally, an OpenCL, which runs on both nVidia and AMD) program that performs fast modular exponentiation of large numbers (i.e. larger than 64 bits; the numbers needed are on the order of 256 bits or larger).  Modular exponentiation is at the heart of both the Fermat Primality Test and the various forms of the Euler Lagrange Lichfitz Test.  It would also be good to find a sieving method implemented in a GPU-specific language, as that is the other math being done in the search miners are doing.

It looks like the linked page implements (or, would have implemented, if the links weren't broken) the Ulam Spiral, which is a method of finding lots of primes and is a strong proof of primality (as opposed to the Fermat Test, which only shows probable primality).  It, like the Sieve of Eratosthenes used in the generation algorithm right now, can be used to calculate every prime number up to a certain number.  If it can be stopped early and still give useful information about a set of numbers then this sieve is applicable to Primecoin (i.e. if you can run some number of iterations of the Ulam Spiral where you only care about a very sparse subset of numbers and when you're done it has eliminated a lot of the composite numbers).  However, without source code it isn't really a big help to developers right now.

If people want me to I will, I'm a fan of Primecoins, and would like to see further development.

I found a Prime generator for CUDA from Nvidia website, and I am wondering whether it is helpful for our Primecoin mining.

https://devtalk.nvidia.com/default/topic/493679/prime-generator-for-cuda/

My p2pclient will beat this problem. By making a sub blockchain with difficulty one less than the main chain's, payment is based on all the blocks you have submitted during the round. The P2P chain will end up producing many many more primes than the main chain does, maybe somebody will take it upon themselves to create a listening node and just store them, since I won't be making a site for the pool it won't be me, which also means I can make it a no-fee pool.

I'm not sure this is the case, or at least it is not as simple.  With hashcash proof-of-work it is impossible to look for lower difficulty shares without also looking for higher difficulty shares.  In Primecoin, on the other hand, as I understand it, one could look for chains of length 7 and find them with much greater frequency than they would find chains of length 7 while looking for chains of length 8 (i.e. pool miners would maximize their share submission by hurting the pool; the tragedy of the commons ensues).

I assume that when the mining algorithm executes it first executes the Sieve of Eratosthenes to build a list of possible primes.  If one finds that there is a list of 7 numbers that passed the sieve and form a chain then they could be checked to see if they form a valid share, even if the sieve eliminated the next value, proving that a block of difficulty 8 or higher is impossible from that start (I am assuming a share difficulty of 7 and a network difficulty of 8 or more).  A miner optimized for finding valid blocks as fast as possible would save computational time by ignoring the chain of length 7 when the difficulty is 8 or higher, while a miner optimized for finding valid shares would check every chain of primes that passes the sieve that is at least (share length) long.

This could be circumvented by requiring the numbers after the share's chain up to the integral network difficulty to all pass a sieve, but I believe that that would break the requirement that shares be fast to verify by the pool host.  Additionally, it would set stringent requirements on how the numbers would have to be sieved which would limit improvements to be made in that area (which seems to be where most of the improvements are being made).

You've made a really innovative coin, Sunny, and I trust you to come up with an innovative solution to this, but it isn't as simple as it may appear at first glance.