Mps backend

AddrGen/Makefile

@@ -1,7 +1,7 @@
 CPPSRC:=$(wildcard *.cpp)
 
 all:
-	${CXX} -o addrgen.bin ${CPPSRC} ${INCLUDE} -I${CUDA_INCLUDE} ${CXXFLAGS} ${LIBS} -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lutil -lcmdparse
+	${CXX} -o addrgen.bin ${CPPSRC} ${INCLUDE} -I${CUDA_INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS} -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lutil -lcmdparse
 	mkdir -p $(BINDIR)
 	cp addrgen.bin $(BINDIR)/addrgen
 

KeyFinder/DeviceManager.cpp

@@ -8,6 +8,11 @@
 #include "clutil.h"
 #endif
 
+#ifdef BUILD_METAL
+#include "MetalKeySearchDevice.h"
+#include <Metal/Metal.hpp>
+#endif
+
 std::vector<DeviceManager::DeviceInfo> DeviceManager::getDevices()
 {
     int deviceId = 0;
@@ -57,5 +62,21 @@ std::vector<DeviceManager::DeviceInfo> DeviceManager::getDevices()
     }
 #endif
 
+#ifdef BUILD_METAL
+    MTL::Device* device = MTL::CreateSystemDefaultDevice();
+    if(device) {
+        DeviceManager::DeviceInfo devInfo;
+        devInfo.name = device->name()->utf8String();
+        devInfo.type = DeviceType::Metal;
+        devInfo.id = deviceId;
+        devInfo.physicalId = 0;
+        devInfo.memory = device->recommendedMaxWorkingSetSize();
+        devInfo.computeUnits = 0;
+        devices.push_back(devInfo);
+        deviceId++;
+        device->release();
+    }
+#endif
+
     return devices;
 }

KeyFinder/DeviceManager.h

@@ -22,7 +22,8 @@ class DeviceType {
 public:
     enum {
         CUDA = 0,
-        OpenCL
+        OpenCL,
+        Metal
     };
 };
 

KeyFinder/Makefile

@@ -11,7 +11,13 @@ ifeq ($(BUILD_OPENCL),1)
 	mkdir -p $(BINDIR)
 	cp clKeyFinder.bin $(BINDIR)/clBitCrack
 endif
+ifeq ($(BUILD_METAL),1)
+	${CXX} -DBUILD_METAL -o metalKeyFinder.bin ${CPPSRC} ${INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS} -lkeyfinder -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lMetalKeySearchDevice -llogger -lutil -lcmdparse
+	mkdir -p $(BINDIR)
+	cp metalKeyFinder.bin $(BINDIR)/metalBitCrack
+endif
 
 clean:
 	rm -rf cuKeyFinder.bin
 	rm -rf clKeyFinder.bin
+	rm -rf metalKeyFinder.bin

KeyFinder/main.cpp

@@ -20,6 +20,10 @@
 #include "CLKeySearchDevice.h"
 #endif
 
+#ifdef BUILD_METAL
+#include "MetalKeySearchDevice.h"
+#endif
+
 typedef struct {
     // startKey is the first key. We store it so that if the --continue
     // option is used, the correct progress is displayed. startKey and
@@ -251,6 +255,12 @@ static KeySearchDevice *getDeviceContext(DeviceManager::DeviceInfo &device, int
     }
 #endif
 
+#ifdef BUILD_METAL
+    if(device.type == DeviceManager::DeviceType::Metal) {
+        return new MetalKeySearchDevice(device.id, pointsPerThread);
+    }
+#endif
+
     return NULL;
 }
 

Makefile

@@ -1,6 +1,6 @@
 
 CUR_DIR=$(shell pwd)
-DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib CLKeySearchDevice CudaKeySearchDevice cudaMath clUtil cudaUtil secp256k1lib Logger embedcl
+DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib CLKeySearchDevice CudaKeySearchDevice MetalKeySearchDevice cudaMath clUtil cudaUtil secp256k1lib Logger embedcl
 
 INCLUDE = $(foreach d, $(DIRS), -I$(CUR_DIR)/$d)
 
@@ -11,6 +11,7 @@ LIBS+=-L$(LIBDIR)
 # C++ options
 CXX=g++
 CXXFLAGS=-O2 -std=c++11
+LDFLAGS=
 
 # CUDA variables
 COMPUTE_CAP=86
@@ -41,6 +42,7 @@ export OPENCL_LIB
 export OPENCL_INCLUDE
 export BUILD_OPENCL
 export BUILD_CUDA
+export BUILD_METAL
 
 TARGETS=dir_addressutil dir_cmdparse dir_cryptoutil dir_keyfinderlib dir_keyfinder dir_secp256k1lib dir_util dir_logger dir_addrgen
 
@@ -53,6 +55,13 @@ ifeq ($(BUILD_OPENCL),1)
 	CXXFLAGS:=${CXXFLAGS} -DCL_TARGET_OPENCL_VERSION=${OPENCL_VERSION}
 endif
 
+ifeq ($(BUILD_METAL),1)
+	TARGETS:=${TARGETS} dir_metalKeySearchDevice
+	CXX=clang++
+	CXXFLAGS+=-std=c++17 -Wno-unused-parameter
+	LDFLAGS+=-framework Metal -framework Foundation
+endif
+
 all:	${TARGETS}
 
 dir_cudaKeySearchDevice: dir_keyfinderlib dir_cudautil dir_logger
@@ -61,6 +70,9 @@ dir_cudaKeySearchDevice: dir_keyfinderlib dir_cudautil dir_logger
 dir_clKeySearchDevice: dir_embedcl dir_keyfinderlib dir_clutil dir_logger
 	make --directory CLKeySearchDevice
 
+dir_metalKeySearchDevice: dir_keyfinderlib dir_logger
+	make --directory MetalKeySearchDevice
+
 dir_embedcl:
 	make --directory embedcl
 
@@ -86,6 +98,10 @@ ifeq ($(BUILD_OPENCL),1)
 	KEYFINDER_DEPS:=$(KEYFINDER_DEPS) dir_clKeySearchDevice
 endif
 
+ifeq ($(BUILD_METAL),1)
+	KEYFINDER_DEPS:=$(KEYFINDER_DEPS) dir_metalKeySearchDevice
+endif
+
 dir_keyfinder:	$(KEYFINDER_DEPS)
 	make --directory KeyFinder
 

Makefile.metal

@@ -0,0 +1,50 @@
+# Makefile for building the Metal backend on macOS
+
+# Compiler
+CXX=clang++
+
+# Directories
+CUR_DIR=$(shell pwd)
+LIBDIR=$(CUR_DIR)/lib
+BINDIR=$(CUR_DIR)/bin
+
+# Source directories
+DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib MetalKeySearchDevice secp256k1lib Logger
+
+# Include paths
+INCLUDE = $(foreach d, $(DIRS), -I$(CUR_DIR)/$d)
+INCLUDE += -I/opt/homebrew/opt/openssl/include
+
+# C++ flags
+CXXFLAGS=-O2 -std=c++17 -Wno-unused-parameter -DBUILD_METAL
+
+# Linker flags
+LDFLAGS=-L/opt/homebrew/opt/openssl/lib -L${LIBDIR} -framework Metal -framework Foundation
+
+# Libraries
+LIBS=-lkeyfinder -laddressutil -lsecp256k1 -lcryptoutil -lMetalKeySearchDevice -llogger -lutil -lcmdparse -lcrypto
+
+# Source files
+SRCS = $(wildcard util/*.cpp) \
+       $(wildcard AddressUtil/*.cpp) \
+       $(wildcard CmdParse/*.cpp) \
+       $(wildcard CryptoUtil/*.cpp) \
+       $(wildcard KeyFinderLib/*.cpp) \
+       $(wildcard MetalKeySearchDevice/*.cpp) \
+       $(wildcard secp256k1lib/*.cpp) \
+       $(wildcard Logger/*.cpp) \
+       KeyFinder/main.cpp \
+       KeyFinder/ConfigFile.cpp \
+       KeyFinder/DeviceManager.cpp
+
+# Target
+all: metalBitCrack
+
+metalBitCrack:
+	mkdir -p ${BINDIR}
+	${CXX} -o ${BINDIR}/metalBitCrack ${SRCS} ${INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS}
+
+clean:
+	rm -rf ${BINDIR}
+
+.PHONY: all clean

MetalKeySearchDevice/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all clean
+
+SRC=$(wildcard *.cpp)
+OBJS=$(SRC:.cpp=.o)
+
+all:    ${OBJS}
+
+%.o: %.cpp
+	${CXX} -c $< -o $@ ${INCLUDE} ${CXXFLAGS}
+
+clean:
+	rm -rf *.o

MetalKeySearchDevice/MetalKeySearchDevice.cpp

@@ -0,0 +1,127 @@
+#include "MetalKeySearchDevice.h"
+#include "Logger.h"
+#include "util.h"
+#include <fstream>
+#include <iostream>
+
+MetalKeySearchDevice::MetalKeySearchDevice(int deviceId, uint64_t keysPerStep) {
+    _device = MTL::CreateSystemDefaultDevice();
+    if(!_device) {
+        throw KeySearchException("Failed to create Metal device");
+    }
+
+    _commandQueue = _device->newCommandQueue();
+    if(!_commandQueue) {
+        throw KeySearchException("Failed to create Metal command queue");
+    }
+
+    std::string source = util::readTextFile("MetalKeySearchDevice/keysearch.metal");
+    if(source.empty()) {
+        throw KeySearchException("Failed to read metal kernel file");
+    }
+
+    NS::Error* error = nullptr;
+    _library = _device->newLibrary(NS::String::string(source.c_str(), NS::UTF8StringEncoding), nullptr, &error);
+    if(!_library) {
+        throw KeySearchException("Failed to create Metal library: " + std::string(error->localizedDescription()->utf8String()));
+    }
+
+    _function = _library->newFunction(NS::String::string("generate_public_key", NS::UTF8StringEncoding));
+    if(!_function) {
+        throw KeySearchException("Failed to create Metal function");
+    }
+
+    _pipelineState = _device->newComputePipelineState(_function, &error);
+    if(!_pipelineState) {
+        throw KeySearchException("Failed to create Metal pipeline state: " + std::string(error->localizedDescription()->utf8String()));
+    }
+
+    this->_keysPerStep = keysPerStep;
+    Logger::log(LogLevel::Info, "MetalKeySearchDevice created");
+}
+
+MetalKeySearchDevice::~MetalKeySearchDevice() {
+    _pipelineState->release();
+    _function->release();
+    _library->release();
+    _commandQueue->release();
+    _device->release();
+    Logger::log(LogLevel::Info, "MetalKeySearchDevice destroyed");
+}
+
+void MetalKeySearchDevice::init(const secp256k1::uint256 &start, int compression, const secp256k1::uint256 &stride) {
+    this->_startKey = start;
+    this->_compression = compression;
+    this->_stride = stride;
+    Logger::log(LogLevel::Info, "MetalKeySearchDevice initialized");
+}
+
+void MetalKeySearchDevice::doStep() {
+    // Create buffers
+    MTL::Buffer* privateKeysBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared);
+    MTL::Buffer* publicKeysXBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared);
+    MTL::Buffer* publicKeysYBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared);
+
+    // Generate private keys
+    uint256_t* privateKeys = (uint256_t*)privateKeysBuffer->contents();
+    for (uint64_t i = 0; i < _keysPerStep; i++) {
+        privateKeys[i] = _startKey + _stride * i;
+    }
+
+    // Create a command buffer
+    MTL::CommandBuffer* commandBuffer = _commandQueue->commandBuffer();
+    MTL::ComputeCommandEncoder*- commandEncoder = commandBuffer->computeCommandEncoder();
+
+    // Set pipeline state and buffers
+    commandEncoder->setComputePipelineState(_pipelineState);
+    commandEncoder->setBuffer(privateKeysBuffer, 0, 0);
+    commandEncoder->setBuffer(publicKeysXBuffer, 0, 1);
+    commandEncoder->setBuffer(publicKeysYBuffer, 0, 2);
+
+    // Dispatch the kernel
+    MTL::Size gridSize = MTL::Size(_keysPerStep, 1, 1);
+    NS::UInteger threadGroupSize = _pipelineState->maxTotalThreadsPerThreadgroup();
+    if (threadGroupSize > _keysPerStep) {
+        threadGroupSize = _keysPerStep;
+    }
+    MTL::Size threadgroupSize = MTL::Size(threadGroupSize, 1, 1);
+    commandEncoder->dispatchThreads(gridSize, threadgroupSize);
+
+    // End encoding and commit the command buffer
+    commandEncoder->endEncoding();
+    commandBuffer->commit();
+    commandBuffer->waitUntilCompleted();
+
+    // TODO: Read results and check for matches
+
+    // Clean up
+    privateKeysBuffer->release();
+    publicKeysXBuffer->release();
+    publicKeysYBuffer->release();
+
+    _startKey = _startKey + _stride * _keysPerStep;
+}
+
+void MetalKeySearchDevice::setTargets(const std::set<KeySearchTarget> &targets) {
+}
+
+size_t MetalKeySearchDevice::getResults(std::vector<KeySearchResult> &results) {
+    return 0;
+}
+
+uint64_t MetalKeySearchDevice::keysPerStep() {
+    return 0;
+}
+
+std::string MetalKeySearchDevice::getDeviceName() {
+    return "Metal Key Search Device";
+}
+
+void MetalKeySearchDevice::getMemoryInfo(uint64_t &freeMem, uint64_t &totalMem) {
+    freeMem = 0;
+    totalMem = 0;
+}
+
+secp256k1::uint256 MetalKeySearchDevice::getNextKey() {
+    return secp256k1::uint256(0);
+}

MetalKeySearchDevice/MetalKeySearchDevice.h

@@ -0,0 +1,35 @@
+#ifndef _METAL_KEY_SEARCH_DEVICE_H
+#define _METAL_KEY_SEARCH_DEVICE_H
+
+#include "KeySearchDevice.h"
+#include <Metal/Metal.hpp>
+
+class MetalKeySearchDevice : public KeySearchDevice {
+private:
+    MTL::Device* _device;
+    MTL::CommandQueue* _commandQueue;
+    MTL::Library* _library;
+    MTL::Function* _function;
+    MTL::ComputePipelineState* _pipelineState;
+
+    secp256k1::uint256 _startKey;
+    secp256k1::uint256 _stride;
+    int _compression;
+    std::vector<KeySearchTarget> _targets;
+    uint64_t _keysPerStep;
+
+public:
+    MetalKeySearchDevice(int deviceId, uint64_t keysPerStep);
+    virtual ~MetalKeySearchDevice();
+
+    virtual void init(const secp256k1::uint256 &start, int compression, const secp256k1::uint256 &stride);
+    virtual void doStep();
+    virtual void setTargets(const std::set<KeySearchTarget> &targets);
+    virtual size_t getResults(std::vector<KeySearchResult> &results);
+    virtual uint64_t keysPerStep();
+    virtual std::string getDeviceName();
+    virtual void getMemoryInfo(uint64_t &freeMem, uint64_t &totalMem);
+    virtual secp256k1::uint256 getNextKey();
+};
+
+#endif