cache work by rolling coinbase

[p2pool.git] / p2pool / bitcoin / worker_interface.py

diff --git a/p2pool/bitcoin/worker_interface.py b/p2pool/bitcoin/worker_interface.py
index e75fbac..0e6d9b9 100644 (file)
--- a/p2pool/bitcoin/worker_interface.py
+++ b/p2pool/bitcoin/worker_interface.py
@@ -40,9 +40,6 @@ class WorkerInterface(object):
         
         self.worker_views = {}
         
-        self.work_cache = {}
-        self.work_cache_times = self.worker_bridge.new_work_event.times
-        
         self.merkle_root_to_handler = expiring_dict.ExpiringDict(300)
     
     def attach_to(self, res, get_handler=None):
@@ -57,7 +54,7 @@ class WorkerInterface(object):
     @defer.inlineCallbacks
     def _getwork(self, request, data, long_poll):
         request.setHeader('X-Long-Polling', '/long-polling')
-        request.setHeader('X-Roll-NTime', 'expire=10')
+        request.setHeader('X-Roll-NTime', 'expire=100')
         request.setHeader('X-Is-P2Pool', 'true')
         if request.getHeader('Host') is not None:
             request.setHeader('X-Stratum', 'stratum+tcp://' + request.getHeader('Host'))
@@ -67,7 +64,7 @@ class WorkerInterface(object):
             if header['merkle_root'] not in self.merkle_root_to_handler:
                 print >>sys.stderr, '''Couldn't link returned work's merkle root with its handler. This should only happen if this process was recently restarted!'''
                 defer.returnValue(False)
-            defer.returnValue(self.merkle_root_to_handler[header['merkle_root']](header, request.getUser() if request.getUser() is not None else '', 0))
+            defer.returnValue(self.merkle_root_to_handler[header['merkle_root']](header, request.getUser() if request.getUser() is not None else '', '\0'*self.worker_bridge.COINBASE_NONCE_LENGTH))
         
         if p2pool.DEBUG:
             id = random.randrange(1000, 10000)
@@ -84,33 +81,54 @@ class WorkerInterface(object):
                 yield self.worker_bridge.new_work_event.get_deferred()
             self.worker_views[request_id] = self.worker_bridge.new_work_event.times
         
-        key = self.worker_bridge.preprocess_request(request.getUser() if request.getUser() is not None else '')
-        
-        if self.work_cache_times != self.worker_bridge.new_work_event.times:
-            self.work_cache = {}
-            self.work_cache_times = self.worker_bridge.new_work_event.times
-        
-        if key in self.work_cache:
-            res, orig_timestamp, handler = self.work_cache.pop(key)
-        else:
-            x, handler = self.worker_bridge.get_work(*key)
-            res = getwork.BlockAttempt(
-                version=x['version'],
-                previous_block=x['previous_block'],
-                merkle_root=bitcoin_data.check_merkle_link(bitcoin_data.hash256(x['coinb1'] + pack.IntType(32).pack(0) + x['coinb2']), x['merkle_link']),
-                timestamp=x['timestamp'],
-                bits=x['bits'],
-                share_target=x['share_target'],
-            )
-            assert res.merkle_root not in self.merkle_root_to_handler
-            orig_timestamp = res.timestamp
+        x, handler = self.worker_bridge.get_work(*self.worker_bridge.preprocess_request(request.getUser() if request.getUser() is not None else ''))
+        res = getwork.BlockAttempt(
+            version=x['version'],
+            previous_block=x['previous_block'],
+            merkle_root=bitcoin_data.check_merkle_link(bitcoin_data.hash256(x['coinb1'] + '\0'*self.worker_bridge.COINBASE_NONCE_LENGTH + x['coinb2']), x['merkle_link']),
+            timestamp=x['timestamp'],
+            bits=x['bits'],
+            share_target=x['share_target'],
+        )
+        assert res.merkle_root not in self.merkle_root_to_handler
         
         self.merkle_root_to_handler[res.merkle_root] = handler
         
-        if res.timestamp + 120 < orig_timestamp + 1800:
-            self.work_cache[key] = res.update(timestamp=res.timestamp + 120), orig_timestamp, handler
-        
         if p2pool.DEBUG:
             print 'POLL %i END identifier=%i' % (id, self.worker_bridge.new_work_event.times)
         
         defer.returnValue(res.getwork(identifier=str(self.worker_bridge.new_work_event.times), submitold=True))
+
+class CachingWorkerBridge(object):
+    def __init__(self, inner):
+        self._inner = inner
+        
+        self.COINBASE_NONCE_LENGTH = (inner.COINBASE_NONCE_LENGTH+1)//2
+        self.new_work_event = inner.new_work_event
+        self.preprocess_request = inner.preprocess_request
+        
+        self._my_bits = (self._inner.COINBASE_NONCE_LENGTH - self.COINBASE_NONCE_LENGTH)*8
+        
+        self._cache = {}
+        self._times = None
+    
+    def get_work(self, *args):
+        if self._times != self.new_work_event.times:
+            self._cache = {}
+            self._times = self.new_work_event.times
+        
+        if args not in self._cache:
+            x, handler = self._inner.get_work(*args)
+            self._cache[args] = x, handler, 0
+        
+        x, handler, nonce = self._cache.pop(args)
+        
+        res = (
+            dict(x, coinb1=x['coinb1'] + pack.IntType(self._my_bits).pack(nonce)),
+            lambda header, user, coinbase_nonce: handler(header, user, pack.IntType(self._my_bits).pack(nonce) + coinbase_nonce),
+        )
+        
+        if nonce + 1 != 2**self._my_bits:
+            self._cache[args] = x, handler, nonce + 1
+        
+        return res