Initial commit

Author: bbfamily

CpuHelper.py

@@ -0,0 +1,34 @@
+# -*- encoding:utf-8 -*-
+from __future__ import print_function
+
+import platform
+
+import psutil
+from osx_cpu_temp import get_cpu_temp
+
+__author__ = 'BBFamily'
+
+
+def get_cpu_temp_proxy():
+    """
+        暂时只支持mac，但是也会返回0.0，方便统一处理
+    """
+    if platform.system().lower().find("windows") >= 0:
+        ret_text = 'get_cpu_temp only support mac now!'
+        print(ret_text)
+        return 0.0, ret_text
+    return get_cpu_temp()
+
+
+def cpu_times():
+    return psutil.cpu_times()
+
+
+def cpu_count(logical=True):
+    return psutil.cpu_count(logical=logical)
+
+
+def cpu_percent(times=False, interval=1, percpu=True):
+    func = psutil.cpu_times_percent if times else psutil.cpu_percent
+
+    return func(interval=interval, percpu=percpu)

Demo.py

@@ -0,0 +1,61 @@
+# -*- encoding:utf-8 -*-
+"""
+    使用sklearn的parallel作为demo
+"""
+import numpy as np
+from ProcessMonitor import add_process_wrapper
+from sklearn.externals.joblib import Parallel
+from sklearn.externals.joblib import delayed
+import time
+
+from concurrent.futures import ProcessPoolExecutor
+
+__author__ = 'BBFamily'
+
+"""
+    只需要在具体process job @add_procee_wrapper就ok了
+"""
+
+
+@add_process_wrapper
+def do_process_job(jb):
+    c = count(jb)
+    end_tick = 100
+    for cb in c:
+        time.sleep(1)
+        if cb % 10 == 0:
+            print(cb)
+        if end_tick < cb:
+            break
+    return jb
+
+
+def when_done(r):
+    print('job {} done:'.format(r.result()))
+
+
+def make_parallel_poll_jobs():
+    with ProcessPoolExecutor() as pool:
+        n_jobs = 10
+        for jb in np.arange(0, n_jobs):
+            future_result = pool.submit(do_process_job, jb)
+            future_result.add_done_callback(when_done)
+
+
+def make_parallel_jobs():
+    n_jobs = 10
+    parallel = Parallel(
+        n_jobs=n_jobs, verbose=0, pre_dispatch='2*n_jobs')
+
+    out = parallel(delayed(do_process_job)(jb) for jb in np.arange(0, n_jobs))
+    return out
+
+
+def count(n):
+    while True:
+        yield n
+        n += 1
+
+
+if __name__ == "__main__":
+    make_parallel_jobs()

Externals/osx-cpu-temp-master/Makefile

@@ -0,0 +1,17 @@
+
+CC     = cc
+CFLAGS = -O2 -Wall
+INC    = -framework IOKit
+PREFIX = /usr/local
+EXEC   = osx-cpu-temp
+
+build : $(EXEC)
+
+clean : 
+	rm $(EXEC)
+
+$(EXEC) : smc.c
+	$(CC) $(CFLAGS) $(INC) -o $@ $?
+
+install : $(EXEC)
+	install $(EXEC) $(PREFIX)/bin

Externals/osx-cpu-temp-master/README.md

@@ -0,0 +1,55 @@
+# OSX CPU Temp
+
+Outputs current CPU temperature for OSX.
+
+## Usage 
+
+### Compiling
+
+```bash
+make
+```
+
+### Running
+
+```bash
+./osx-cpu-temp
+```
+
+or
+
+```bash
+sudo make install # installs to /usr/local/bin
+osx-cpu-temp
+```
+
+### Using clib
+
+```bash
+clib install lavoiesl/osx-cpu-temp
+```
+
+### Output example
+
+```
+61.8°C
+```
+
+### Options
+
+ * `-C` Output temperature in Celsius (default).
+ * `-F` Output temperature in Fahrenheit.
+
+## Maintainer 
+
+Sébastien Lavoie <[email protected]>
+
+### Source 
+
+Apple System Management Control (SMC) Tool 
+Copyright (C) 2006
+
+### Inspiration 
+
+ * http://www.eidac.de/smcfancontrol/
+ * https://github.com/hholtmann/smcFanControl/tree/master/smc-command

Externals/osx-cpu-temp-master/osx-cpu-temp

@@ -0,0 +1,8 @@
+{
+  "name": "osx-cpu-temp",
+  "version": "0.0.0",
+  "repo": "lavoiesl/osx-cpu-temp",
+  "description": "Outputs current CPU temperature in °C for OSX",
+  "keywords": ["osx", "cpu", "temperature", "sensors"],
+  "install": "make install"
+}

Externals/osx-cpu-temp-master/package.json

@@ -0,0 +1,196 @@
+/*
+ * Apple System Management Control (SMC) Tool 
+ * Copyright (C) 2006 devnull 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <IOKit/IOKitLib.h>
+
+#include "smc.h"
+
+static io_connect_t conn;
+
+UInt32 _strtoul(char *str, int size, int base)
+{
+    UInt32 total = 0;
+    int i;
+
+    for (i = 0; i < size; i++)
+    {
+        if (base == 16)
+            total += str[i] << (size - 1 - i) * 8;
+        else
+           total += (unsigned char) (str[i] << (size - 1 - i) * 8);
+    }
+    return total;
+}
+
+void _ultostr(char *str, UInt32 val)
+{
+    str[0] = '\0';
+    sprintf(str, "%c%c%c%c", 
+            (unsigned int) val >> 24,
+            (unsigned int) val >> 16,
+            (unsigned int) val >> 8,
+            (unsigned int) val);
+}
+
+kern_return_t SMCOpen(void)
+{
+    kern_return_t result;
+    io_iterator_t iterator;
+    io_object_t   device;
+
+    CFMutableDictionaryRef matchingDictionary = IOServiceMatching("AppleSMC");
+    result = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &iterator);
+    if (result != kIOReturnSuccess)
+    {
+        printf("Error: IOServiceGetMatchingServices() = %08x\n", result);
+        return 1;
+    }
+
+    device = IOIteratorNext(iterator);
+    IOObjectRelease(iterator);
+    if (device == 0)
+    {
+        printf("Error: no SMC found\n");
+        return 1;
+    }
+
+    result = IOServiceOpen(device, mach_task_self(), 0, &conn);
+    IOObjectRelease(device);
+    if (result != kIOReturnSuccess)
+    {
+        printf("Error: IOServiceOpen() = %08x\n", result);
+        return 1;
+    }
+
+    return kIOReturnSuccess;
+}
+
+kern_return_t SMCClose()
+{
+    return IOServiceClose(conn);
+}
+
+
+kern_return_t SMCCall(int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure)
+{
+    size_t   structureInputSize;
+    size_t   structureOutputSize;
+
+    structureInputSize = sizeof(SMCKeyData_t);
+    structureOutputSize = sizeof(SMCKeyData_t);
+
+    #if MAC_OS_X_VERSION_10_5
+    return IOConnectCallStructMethod( conn, index,
+                            // inputStructure
+                            inputStructure, structureInputSize,
+                            // ouputStructure
+                            outputStructure, &structureOutputSize );
+    #else
+    return IOConnectMethodStructureIStructureO( conn, index,
+                                                structureInputSize, /* structureInputSize */
+                                                &structureOutputSize,   /* structureOutputSize */
+                                                inputStructure,        /* inputStructure */
+                                                outputStructure);       /* ouputStructure */
+    #endif
+
+}
+
+kern_return_t SMCReadKey(UInt32Char_t key, SMCVal_t *val)
+{
+    kern_return_t result;
+    SMCKeyData_t  inputStructure;
+    SMCKeyData_t  outputStructure;
+
+    memset(&inputStructure, 0, sizeof(SMCKeyData_t));
+    memset(&outputStructure, 0, sizeof(SMCKeyData_t));
+    memset(val, 0, sizeof(SMCVal_t));
+
+    inputStructure.key = _strtoul(key, 4, 16);
+    inputStructure.data8 = SMC_CMD_READ_KEYINFO;
+
+    result = SMCCall(KERNEL_INDEX_SMC, &inputStructure, &outputStructure);
+    if (result != kIOReturnSuccess)
+        return result;
+
+    val->dataSize = outputStructure.keyInfo.dataSize;
+    _ultostr(val->dataType, outputStructure.keyInfo.dataType);
+    inputStructure.keyInfo.dataSize = val->dataSize;
+    inputStructure.data8 = SMC_CMD_READ_BYTES;
+
+    result = SMCCall(KERNEL_INDEX_SMC, &inputStructure, &outputStructure);
+    if (result != kIOReturnSuccess)
+        return result;
+
+    memcpy(val->bytes, outputStructure.bytes, sizeof(outputStructure.bytes));
+
+    return kIOReturnSuccess;
+}
+
+double SMCGetTemperature(char *key)
+{
+    SMCVal_t val;
+    kern_return_t result;
+
+    result = SMCReadKey(key, &val);
+    if (result == kIOReturnSuccess) {
+        // read succeeded - check returned value
+        if (val.dataSize > 0) {
+            if (strcmp(val.dataType, DATATYPE_SP78) == 0) {
+                // convert sp78 value to temperature
+                int intValue = val.bytes[0] * 256 + (unsigned char)val.bytes[1];
+                return intValue / 256.0;
+            }
+        }
+    }
+    // read failed
+    return 0.0;
+}
+
+double convertToFahrenheit(double celsius) {
+  return (celsius * (9.0 / 5.0)) + 32.0;
+}
+
+int main(int argc, char *argv[])
+{
+    char scale = 'C';
+
+    int c;
+    while ((c = getopt(argc, argv, "CF")) != -1) {
+      switch (c) {
+        case 'F':
+        case 'C':
+          scale = c;
+          break;
+      }
+    }
+
+    SMCOpen();
+    double temperature = SMCGetTemperature(SMC_KEY_CPU_TEMP);
+    SMCClose();
+
+    if (scale == 'F') {
+      temperature = convertToFahrenheit(temperature);
+    }
+
+    printf("%0.1f°%c\n", temperature, scale);
+
+    return 0;
+}