func loadProgramSource(filename string) ([][]byte, []cl.CL_size_t, error) {
var program_buffer [1][]byte
var program_size [1]cl.CL_size_t
/* Read each program file and place content into buffer array */
program_handle, err := os.Open(filename)
if err != nil {
return nil, nil, err
}
defer program_handle.Close()
fi, err := program_handle.Stat()
if err != nil {
return nil, nil, err
}
program_size[0] = cl.CL_size_t(fi.Size())
program_buffer[0] = make([]byte, program_size[0])
read_size, err := program_handle.Read(program_buffer[0])
if err != nil || cl.CL_size_t(read_size) != program_size[0] {
return nil, nil, err
}
return program_buffer[:], program_size[:], nil
}
func (d *Device) runDevice() error {
minrLog.Infof("Started GPU #%d", d.index)
outputData := make([]uint32, outputBufferSize)
var status cl.CL_int
for {
d.updateCurrentWork()
select {
case <-d.quit:
return nil
default:
}
// Increment nonce1
d.lastBlock[nonce1Word]++
// arg 0: pointer to the buffer
obuf := d.outputBuffer
status = cl.CLSetKernelArg(d.kernel, 0, cl.CL_size_t(unsafe.Sizeof(obuf)), unsafe.Pointer(&obuf))
if status != cl.CL_SUCCESS {
return clError(status, "CLSetKernelArg")
}
// args 1..8: midstate
for i := 0; i < 8; i++ {
ms := d.midstate[i]
status = cl.CLSetKernelArg(d.kernel, cl.CL_uint(i+1), uint32Size, unsafe.Pointer(&ms))
if status != cl.CL_SUCCESS {
return clError(status, "CLSetKernelArg")
}
}
// args 9..20: lastBlock except nonce
i2 := 0
for i := 0; i < 12; i++ {
if i2 == nonce0Word {
i2++
}
lb := d.lastBlock[i2]
status = cl.CLSetKernelArg(d.kernel, cl.CL_uint(i+9), uint32Size, unsafe.Pointer(&lb))
if status != cl.CL_SUCCESS {
return clError(status, "CLSetKernelArg")
}
i2++
}
// Clear the found count from the buffer
status = cl.CLEnqueueWriteBuffer(d.queue, d.outputBuffer, cl.CL_FALSE, 0, uint32Size, unsafe.Pointer(&zeroSlice[0]), 0, nil, nil)
if status != cl.CL_SUCCESS {
return clError(status, "CLEnqueueWriteBuffer")
}
// Execute the kernel
var globalWorkSize [1]cl.CL_size_t
globalWorkSize[0] = globalWorksize
var localWorkSize [1]cl.CL_size_t
localWorkSize[0] = localWorksize
status = cl.CLEnqueueNDRangeKernel(d.queue, d.kernel, 1, nil, globalWorkSize[:], localWorkSize[:], 0, nil, nil)
if status != cl.CL_SUCCESS {
return clError(status, "CLEnqueueNDRangeKernel")
}
// Read the output buffer
cl.CLEnqueueReadBuffer(d.queue, d.outputBuffer, cl.CL_TRUE, 0, uint32Size*outputBufferSize, unsafe.Pointer(&outputData[0]), 0, nil, nil)
if status != cl.CL_SUCCESS {
return clError(status, "CLEnqueueReadBuffer")
}
for i := uint32(0); i < outputData[0]; i++ {
minrLog.Debugf("Found candidate: %d", outputData[i+1])
d.foundCandidate(d.lastBlock[nonce1Word], outputData[i+1])
}
d.workDoneLast += globalWorksize
d.workDoneTotal += globalWorksize
}
}
package main
import (
"encoding/binary"
"encoding/hex"
"fmt"
"os"
"unsafe"
"github.com/Dirbaio/gominer/blake256"
"github.com/Dirbaio/gominer/cl"
)
const (
outputBufferSize = cl.CL_size_t(64)
globalWorksize = 65536 * 1024
localWorksize = 64
uint32Size = cl.CL_size_t(unsafe.Sizeof(cl.CL_uint(0)))
nonce0Word = 3
nonce1Word = 4
nonce2Word = 5
)
var zeroSlice = []cl.CL_uint{cl.CL_uint(0)}
func loadProgramSource(filename string) ([][]byte, []cl.CL_size_t, error) {
var program_buffer [1][]byte
var program_size [1]cl.CL_size_t
/* Read each program file and place content into buffer array */