stats submissions

Author: JohnnyFFM

config.yaml

@@ -1,9 +1,10 @@
-numeric_id: 12234949781109786614      # numeric ID to emulate
-#start_nonce: 0                        # start_nonce for emulation, default = rand
-secret_phrase: 'sent innocent black neighbor nose cruel surround puff marry around dumb warn'    # empty for pool, passphrase for Burst solo
+numeric_id: 8877950902124165183       # numeric ID to emulate
+#start_nonce: 0                       # start_nonce for emulation, default = rand
+secret_phrase: ''                     # empty for pool, passphrase for Burst solo
 blocktime: 240                        # needed for capacity estimate 
 
-url: 'http://localhost:8125'
+url: 'http://gpupool.de:7777/'      	# bencher stats pool
+#url: 'http://localhost:8125'         # local wallet
 
 cpu_threads: 0                        # default 0 (=cpu disabled)
 cpu_task_size: 262144                 # default 262144, value in nonces
@@ -17,7 +18,7 @@ get_mining_info_interval: 1000        # default 1000ms
 timeout: 3000                         # default 3000ms
 send_proxy_details: true              # default true
 #additional_headers:                  # add/overwrite html headers (optional)
-#  "AccountKey" : "1234567890"
+#  "X-MinerAlias" : "JohnnyFFM"
 
 console_log_level: 'info'             # default Info, options (off, error, warn, info, debug, trace)
 logfile_log_level: 'warn'             # default Warn, options (off, error, warn, info, debug, trace)

src/com/client.rs

@@ -137,12 +137,16 @@ impl Client {
     }
 
     /// Get current mining info.
-    pub fn get_mining_info(&self, capacity: u64, additional_headers: Arc<HashMap<String, String>>) -> impl Future<Item = MiningInfoResponse, Error = FetchError> {
+    pub fn get_mining_info(&self, capacity: u64, additional_headers: Arc<HashMap<String, String>>, xpu_string : Arc<String>) -> impl Future<Item = MiningInfoResponse, Error = FetchError> {
         let mut headers = (*self.headers).clone();
         headers.insert(
             "X-Capacity",
             capacity.to_string().parse().unwrap(),
         );
+        headers.insert(
+            "X-Xpu",
+            xpu_string.parse().unwrap(),
+        );
         for (key, value) in &*additional_headers {
             let header_name = HeaderName::from_bytes(&key.clone().into_bytes()).unwrap();
             headers.insert(header_name, value.parse().unwrap());

src/main.rs

@@ -104,14 +104,33 @@ fn main() {
         &simd_extension
     );
 
+    let mut cpu_string = format!(
+        "cpu: {} [using {} of {} cores{}{:?}]",
+        cpu_name,
+        cpu_threads,
+        num_cpus::get(),
+        if let SimdExtension::None = &simd_extension {
+            ""
+        } else {
+            " + "
+        },
+        &simd_extension
+    );
+
+    cpu_string.push_str(&", ".to_owned());
+
+    #[cfg(not(feature = "opencl"))]
+    let gpu_string = "".to_owned();
     #[cfg(not(feature = "opencl"))]
-    let gpu_mem_needed = 0u64;
+    let gpu_mem_needed = 0u64;    
     #[cfg(feature = "opencl")]
-    let _gpu_mem_needed = if !cfg_loaded.gpus.is_empty() {
+    let (_gpu_mem_needed, gpu_string) = if !cfg_loaded.gpus.is_empty() {
         gpu_get_info(&cfg_loaded.gpus, false)
     } else {
-        0
+        (0,"".to_owned())
     };
+    cpu_string.push_str(&gpu_string);
+        
     #[cfg(feature = "opencl")]
     info!("gpu extensions: OpenCL");
 
@@ -128,7 +147,7 @@ fn main() {
     );
 
     let rt = Builder::new().core_threads(1).build().unwrap();
-    let m = Miner::new(cfg_loaded, simd_extension, cpu_threads, rt.executor());
+    let m = Miner::new(cfg_loaded, simd_extension, cpu_threads, rt.executor(), cpu_string);
     m.run();
     rt.shutdown_on_idle().wait().unwrap();
 }

src/miner.rs

@@ -33,7 +33,8 @@ pub struct Miner {
     blocktime: u64,
     gpus: Vec<GpuConfig>,
     get_mining_info_interval: u64,
-    additional_headers: Arc<HashMap<String, String>>
+    additional_headers: Arc<HashMap<String, String>>,
+    xpu_string: String,
 }
 
 pub struct State {
@@ -111,6 +112,7 @@ impl Miner {
         simd_extensions: SimdExtension,
         cpu_threads: usize,
         executor: TaskExecutor,
+        xpu_string: String,
     ) -> Miner {
         info!("server: {}", cfg.url);
         let additional_headers = Arc::new(cfg.additional_headers);
@@ -136,6 +138,7 @@ impl Miner {
             gpus: cfg.gpus,
             get_mining_info_interval: max(1000, cfg.get_mining_info_interval),
             additional_headers: additional_headers.clone(),
+            xpu_string,
         }
     }
 
@@ -164,6 +167,7 @@ impl Miner {
         let inner_tx_rounds = tx_rounds.clone();
         let get_mining_info_interval = self.get_mining_info_interval;
         let additional_headers = self.additional_headers.clone();
+        let xpu_string = Arc::new(self.xpu_string);
         // run main mining loop on core
         self.executor.clone().spawn(
             Interval::new_interval(Duration::from_millis(get_mining_info_interval))
@@ -174,7 +178,7 @@ impl Miner {
                     let capacity = state2.capacity;
                     drop(state2);
                     let tx_rounds = inner_tx_rounds.clone();
-                    request_handler.get_mining_info(capacity, additional_headers.clone()).then(move |mining_info| {
+                    request_handler.get_mining_info(capacity, additional_headers.clone(), xpu_string.clone()).then(move |mining_info| {
                         match mining_info {
                             Ok(mining_info) => {
                                 let mut state = state.lock().unwrap();

src/ocl.rs

@@ -193,8 +193,9 @@ fn get_cores(device: core::DeviceId) -> u32 {
     }
 }
 
-pub fn gpu_get_info(gpus: &[GpuConfig], quiet: bool) -> u64 {
+pub fn gpu_get_info(gpus: &[GpuConfig], quiet: bool) -> (u64, String) {
     let mut total_mem_needed = 0u64;
+    let mut gpu_string: String = "".to_owned();
     for gpu in gpus.iter() {
         let platform_ids = core::get_platform_ids().unwrap();
         if gpu.platform_id >= platform_ids.len() {
@@ -249,7 +250,11 @@ pub fn gpu_get_info(gpus: &[GpuConfig], quiet: bool) -> u64 {
             println!("Shutting down...");
             process::exit(0);
         }
-
+        gpu_string.push_str(&"gpu(s): ".to_owned());
+        gpu_string.push_str(&to_string!(core::get_device_info(&device, DeviceInfo::Vendor)));    
+        gpu_string.push_str(&" - ".to_owned());   
+        gpu_string.push_str(&to_string!(core::get_device_info(&device, DeviceInfo::Name)));
+        gpu_string.push_str(&",".to_owned());
         if !quiet {
             info!(
                 "gpu: {} - {} [using {} of {} cores]",
@@ -269,7 +274,7 @@ pub fn gpu_get_info(gpus: &[GpuConfig], quiet: bool) -> u64 {
 
         total_mem_needed += mem_needed as u64 / 2;
     }
-    total_mem_needed
+    (total_mem_needed, gpu_string)
 }
 
 pub fn gpu_init(gpus: &[GpuConfig]) -> Vec<Arc<GpuContext>> {

src/request.rs

@@ -143,8 +143,8 @@ impl RequestHandler {
         executor.spawn(stream);
     }
 
-    pub fn get_mining_info(&self, capacity: u64,  additional_headers: Arc<HashMap<String, String>>) -> impl Future<Item = MiningInfoResponse, Error = FetchError> {
-        self.client.get_mining_info(capacity, additional_headers)
+    pub fn get_mining_info(&self, capacity: u64,  additional_headers: Arc<HashMap<String, String>>, xpu_string: Arc<String>) -> impl Future<Item = MiningInfoResponse, Error = FetchError> {
+        self.client.get_mining_info(capacity, additional_headers, xpu_string)
     }
 
     pub fn submit_nonce(