http://burst.cryptoport.io/acc/2715798095717378439 - Now there is some mining power!
Looks like he's 15.5% of the hashpower on my v2 pool.
I started getting "Unable to get mining info from wallet" today using your pool.
Topic: [ANN][BURST] Burst | Efficient HDD Mining | New 1.2.3 Fork block 92000 - page 923. (Read 2170895 times)
September 09, 2014, 03:57:18 AM
Looks like he's 15.5% of the hashpower on my v2 pool.
I started getting "Unable to get mining info from wallet" today using your pool.
September 09, 2014, 03:56:26 AM
The GPUplotter is not working - using EXACTLY the config you have. Did you install the OpenCL driver from AMD?
September 09, 2014, 03:53:28 AM
Hi everyone,
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
It's nice to see someone else working on this, since I seem to have failed in it.Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
Found the "randomness" cause. NVIDIA is caching the kernel after the first build and rebuild it from time to time. By cleaning the cache, I can force the kernel build and speed up the debugging process.
I will notify you as soon as the crash cause is found and corrected.
September 09, 2014, 03:51:09 AM
anyone tried mining BURST on cloud yet??
not on a public cloud which can be setuped to automatically clone plotting/mining instances but on my private cloud manually ;-)on centos you only install the core system from the setup and run this:
yum groupinstall "Development Tools"
yum install java* screen git
mkdir burst
cd burst
git clone https://github.com/BurstProject/burstcoin
git clone https://github.com/BurstProject/pocminer
cd burstcoin
chmod +x *.sh
./compile.sh
screen -dmS wallet ./run.sh
cd..
cd pocminer
chmod +x *.sh
./compile.sh
screen -dmS mine ./run_mine.sh
upload or generate your passphrase.txt
screen -dmS plot ./run_generate.sh address start count stagger threads
Entered this: yum groupinstall "Development Tools"
My server and the provider's entire website went down lol....
https://bchain.info/BURST/tools/calculator must be using the same host I do, site is down too
September 09, 2014, 03:50:43 AM
Quote
This is my parameter
Code:
gpuPlotGenerator.exe plots myaccount 68847637 18500000 4096 256
I run it, it started, but plot isn't generated. Win7 64bit, 280x.
If plot file is to 0bites but in the plot folders, that's normal it will grow with the time
September 09, 2014, 03:49:19 AM
Quote
This is my parameter
Code:
gpuPlotGenerator.exe plots myaccount 68847637 18500000 4096 256
I run it, it started, but plot isn't generated. Win7 64bit, 280x.
September 09, 2014, 03:49:03 AM
YES. Cross-Fire Card.
You mean you have more than one card on your computer that's right?
Tried your setting but not working on mine. Perhaps due to multi-gpu.
You mean you have more than one card on your computer that's right?
I have Multi card too (R9 290X) but not in crossfire
September 09, 2014, 03:48:44 AM
What is your full parameter ?
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
: the path to the plots directory
: number of parrallel threads for each work group
So the usage would be like this: "D:/gpuPlotGenerator 0 819200 4096
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
Hi everyone,
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
It's nice to see someone else working on this, since I seem to have failed in it.Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
So the usage would be like this: "D:/gpuPlotGenerator
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
Wow! So it really works on some models after all! Glad to read it. I am still investigating to correct the bug that occurs on the other graphic cards.
Thank you for your feedback.
I'm getting "Insufficient Private Resource" error on a HD7970.
September 09, 2014, 03:47:42 AM
YES. Cross-Fire Card.
You mean you have more than one card on your computer that's right?
Tried your setting but not working on mine. Perhaps due to multi-gpu.
You mean you have more than one card on your computer that's right?
September 09, 2014, 03:46:56 AM
Tried your setting but not working on mine. Perhaps due to multi-gpu.
You mean you have more than one card on your computer that's right?
September 09, 2014, 03:46:02 AM
What is your full parameter ?
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
: the path to the plots directory
: number of parrallel threads for each work group
So the usage would be like this: "D:/gpuPlotGenerator 0 819200 4096
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
Hi everyone,
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
It's nice to see someone else working on this, since I seem to have failed in it.Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
So the usage would be like this: "D:/gpuPlotGenerator
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
Wow! So it really works on some models after all! Glad to read it. I am still investigating to correct the bug that occurs on the other graphic cards.
Thank you for your feedback.
I make an other feedback when finish
September 09, 2014, 03:45:34 AM
Tried your setting but not working on mine. Perhaps due to multi-gpu.
This is my parameter
What is your full parameter ?
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
: the path to the plots directory
: number of parrallel threads for each work group
So the usage would be like this: "D:/gpuPlotGenerator 0 819200 4096
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
Hi everyone,
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
After many hours of setup I finally made it. I have a 1Tb generation in progress and 3x100Gb already finished.
I would like to test the V2 pool but I haven't any BURST for now. Could someone send me 1 BURST to test it please ? Here is my address : BURST-YA29-QCEW-QXC3-BKXDL.
Regarding the plot generation, I found an OpenCL implementation of Shabal (https://github.com/aznboy84/X15GPU/blob/master/kernel/shabal.cl) that could be used to make a GPU version of the generator. I will try to work on it when I have some free time.
Regards
Hi everyone,
As promised I have been working on a GPU plot generator on the last few days. I made a little program built on top of OpenCL, and it seems to work pretty well in CPU mode. Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
Here is a preview you can test for now :
gpuPlotGenerator-src-1.0.0.7z : https://mega.co.nz/#!bcF2yKKL!3Ud86GaibgvwBehoxkbO4UNdiBgsaixRx7ksHrgNbDI
gpuPlotGenerator-bin-win-x86-1.0.0.7z : https://mega.co.nz/#!HJsziTCK!UmAMoEHQ3z34R4RsXoIkYo9rYd4LnFtO_pw-R4KObJs
I will build another release in the end of the day with some minor improvements (threads per compute unit selection, output of OpenCL error codes, improvement of the Makefile to generate the distribution directly).
I will also try to figure out another mean to dispatch the work between the GPU threads to reduce the amount of private memory needed by the program.
For the windows people, you can use the binary version directly.
For the linux people, just download the source archive, make sure to modify the OpenCL library and lib path in the makefile (and maybe the executable name), and build the project via "make". To run the program, you need the "kernel" and the "plots" directories beside the executable.
The executable usage is : ./gpuPlotGenerator
The parameters are the same as the original plot generator, without the threads number.
If you find bugs or if you want some new features, let me now.
If you want to support me, here are my Bitcoin and Burst addresses :
Bitcoin: 138gMBhCrNkbaiTCmUhP9HLU9xwn5QKZgD
Burst: BURST-YA29-QCEW-QXC3-BKXDL
Regards
Unfortunately, I can't test the GPU mode as it requires a very powerfull graphic card (with at least 46kB private memory per compute unit, because the algorithm needs at least 4096*64 static bytes to store an entire plot).
It's nice to see someone else working on this, since I seem to have failed in it.Private memory is actually part of global on AMD cards, so storing it in private isn't any better than just using global for everything; it's local that needs to aimed for for the massive speedup. No AMD cards have more than 64KB local per workgroup, which makes storing it all in local impossible however.
I haven't tried your implementation yet, but on my own first attempt, I also used global on everything also, and the result was faster than the java plotter, but slower than dcct's c plotter. My 2nd attempt used a 32KB local buffer I rotated through for storing the currently being hashed stuff, however I couldn't figure out how to get it copied also to global fast enough, and the local -> global copy killed the performance.
You might be interested in those kernels here: https://bitcointalksearch.org/topic/m.8695829
Thanks, I will look at your kernels to see if I can find a better solution.
Here is the new version. I reduced the amount of memory used from 40KB to about 1KB per unit. The only drawback is that it requires twice the global memory as before. I will search a mean to reduce this overhead later.
In CPU mode, it all goes pretty well (when no graphic card is detected).
The GPU mode is still kind of buggy on my graphic card (an old GeForce 9300M GS), don't know the exact reason yet. Sometimes it works, sometimes not. I will try to fix this issue tomorrow.
Here are the files :
gpuPlotGenerator-src-1.1.0.7z : https://mega.co.nz/#!iYFWAL5B!BvtmRQ5qGq4gGwjDglFNtDtNIX4LDaUvATBtClBdTlQ
gpuPlotGenerator-bin-win-x86-1.1.0.7z : https://mega.co.nz/#!aBVGBBQD!tBsRtb8VrHR12_anrFTrl41U0fPQu_OqFnxyi5nCyBY
For the linux users, the Makefile has a new target named "dist" that builds and copy/paste all the necessary files to the "bin" directory.
The executable usage is : ./gpuPlotGenerator
So the usage would be like this: "D:/gpuPlotGenerator
Is that format correct? Is the thread count need for gpu plotting(Point out in bold)? What's the nonce/minute rate?
Hi,
This is still a buggy early stage version. I post it here to have feedback from people who owns more powerfull graphic cards (the behaviour may vary from one card to another).
But yes, the final usage would be the one you mentioned. The threads parameter is the number of threads used in the local work group. In GPU mode, the value should be a multiple a 64, 256 is the typical value for most of the cards.
Ok i made a test with my R9 290
I Put 256 in thread (apparently can't put more)
And in 1min15 i generate from nonce 888597 to nonce 900885, So 9830 nonce minute, not bad at all
This is my parameter
Code:
gpuPlotGenerator.exe plots myaccount 68847637 18500000 4096 256
September 09, 2014, 03:45:13 AM
http://burst.cryptoport.io/acc/2715798095717378439 - Now there is some mining power!
Looks like he's 15.5% of the hashpower on my v2 pool.
September 09, 2014, 03:44:36 AM
Proof that gpu plotter works for me
290x?
I cant get it working on my 280x card
Yep right, i post my config some post before
September 09, 2014, 03:40:59 AM
300 satoshi today. Not stable at all.
10 days and price still not rise of 1 satoshi.
10 days and price still not rise of 1 satoshi.
September 09, 2014, 03:39:50 AM
Proof that gpu plotter works for me
290x?
I cant get it working on my 280x card
September 09, 2014, 03:37:07 AM
Proof that gpu plotter works for me
September 09, 2014, 03:35:05 AM
What config you use???
I have tried this on my 280x:
---> gpuPlotGenerator.exe "C:\Users\Fantom\Desktop\GPU_POC\plots" NUMERICALADRESS 0 16382 4096 4
and it just exits without writing new file..
Code:
gpuPlotGenerator.exe plots myaccount 68847637 18500000 4096 256
September 09, 2014, 03:34:11 AM
http://burst.cryptoport.io/acc/2715798095717378439 - Now there is some mining power!
Wow how many TB?
Jump to: