jsonlite
импортирует JSON в фрейм данных. Он может произвольно сгладить вложенные объекты. Вложенными массивами будут кадры данных.
> library(jsonlite)
> winners <- fromJSON("winners.json", flatten=TRUE)
> colnames(winners)
[1] "winner" "votes" "startPrice" "lastVote.timestamp" "lastVote.user.name" "lastVote.user.user_id"
> winners[,c("winner","startPrice","lastVote.user.name")]
winner startPrice lastVote.user.name
1 68694999 0 Lamur
> winners[,c("votes")]
[[1]]
ts user.name user.user_id
1 Thu Mar 25 03:13:01 UTC 2010 Lamur 68694999
2 Thu Mar 25 03:13:08 UTC 2010 Lamur 68694999
Некоторые вышеупомянутые значения легко доступны от соответствующего API WIN32, я просто перечисляю их здесь для полноты. Другие, однако, должны быть получены из библиотеки Performance Data Helper (PDH), который "немного неинтуитивен" и берет большой болезненный метод проб и ошибок для взятий за работу. (По крайней мере, это взяло меня долгое время, возможно, я был только немного глуп...)
Примечание: для ясности вся проверка ошибок была опущена от следующего кода. Действительно проверьте коды возврата...!
Общая Виртуальная память:
#include "windows.h"
MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;
Примечание: имя "TotalPageFile" является немного вводящим в заблуждение здесь. В действительности этот параметр дает "Размер Виртуальной памяти", который является размером файла подкачки плюс установленная RAM.
Виртуальная память в настоящее время использовала:
Тот же код как в "Общей Виртуальной памяти" и затем
DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
Виртуальная память, в настоящее время используемая текущим процессом:
#include "windows.h"
#include "psapi.h"
PROCESS_MEMORY_COUNTERS_EX pmc;
GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
SIZE_T virtualMemUsedByMe = pmc.PrivateUsage;
Общая Физическая память (RAM):
Тот же код как в "Общей Виртуальной памяти" и затем
DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
Физическая память в настоящее время использовала:
Same code as in "Total Virtual Memory" and then
DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
Физическая память, в настоящее время используемая текущим процессом:
Тот же код как в "Виртуальной памяти, в настоящее время используемой текущим процессом" и затем
SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
, ЦП в настоящее время использовал:
#include "TCHAR.h"
#include "pdh.h"
static PDH_HQUERY cpuQuery;
static PDH_HCOUNTER cpuTotal;
void init(){
PdhOpenQuery(NULL, NULL, &cpuQuery);
// You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
PdhCollectQueryData(cpuQuery);
}
double getCurrentValue(){
PDH_FMT_COUNTERVALUE counterVal;
PdhCollectQueryData(cpuQuery);
PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
return counterVal.doubleValue;
}
ЦП, в настоящее время используемый текущим процессом:
#include "windows.h"
static ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
static int numProcessors;
static HANDLE self;
void init(){
SYSTEM_INFO sysInfo;
FILETIME ftime, fsys, fuser;
GetSystemInfo(&sysInfo);
numProcessors = sysInfo.dwNumberOfProcessors;
GetSystemTimeAsFileTime(&ftime);
memcpy(&lastCPU, &ftime, sizeof(FILETIME));
self = GetCurrentProcess();
GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));
memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));
}
double getCurrentValue(){
FILETIME ftime, fsys, fuser;
ULARGE_INTEGER now, sys, user;
double percent;
GetSystemTimeAsFileTime(&ftime);
memcpy(&now, &ftime, sizeof(FILETIME));
GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
memcpy(&sys, &fsys, sizeof(FILETIME));
memcpy(&user, &fuser, sizeof(FILETIME));
percent = (sys.QuadPart - lastSysCPU.QuadPart) +
(user.QuadPart - lastUserCPU.QuadPart);
percent /= (now.QuadPart - lastCPU.QuadPart);
percent /= numProcessors;
lastCPU = now;
lastUserCPU = user;
lastSysCPU = sys;
return percent * 100;
}
На Linux выбор, который казался очевидным сначала, состоял в том, чтобы использовать API POSIX как [1 116] и т.д. Я провел некоторое время, пытаясь заставить это работать, но никогда не получал значимые значения. Когда я наконец проверил сами источники ядра, я узнал, что, по-видимому, эти API полностью еще не реализованы с ядра Linux 2.6!?
В конце я получил все значения через комбинацию чтения псевдофайловой системы /proc
и вызовы ядра.
Общая Виртуальная память:
#include "sys/types.h"
#include "sys/sysinfo.h"
struct sysinfo memInfo;
sysinfo (&memInfo);
long long totalVirtualMem = memInfo.totalram;
//Add other values in next statement to avoid int overflow on right hand side...
totalVirtualMem += memInfo.totalswap;
totalVirtualMem *= memInfo.mem_unit;
Виртуальная память в настоящее время использовала:
Тот же код как в "Общей Виртуальной памяти" и затем
long long virtualMemUsed = memInfo.totalram - memInfo.freeram;
//Add other values in next statement to avoid int overflow on right hand side...
virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
virtualMemUsed *= memInfo.mem_unit;
Виртуальная память, в настоящее время используемая текущим процессом:
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
int parseLine(char* line){
// This assumes that a digit will be found and the line ends in " Kb".
int i = strlen(line);
const char* p = line;
while (*p <'0' || *p > '9') p++;
line[i-3] = '\0';
i = atoi(p);
return i;
}
int getValue(){ //Note: this value is in KB!
FILE* file = fopen("/proc/self/status", "r");
int result = -1;
char line[128];
while (fgets(line, 128, file) != NULL){
if (strncmp(line, "VmSize:", 7) == 0){
result = parseLine(line);
break;
}
}
fclose(file);
return result;
}
Общая Физическая память (RAM):
Тот же код как в "Общей Виртуальной памяти" и затем
long long totalPhysMem = memInfo.totalram;
//Multiply in next statement to avoid int overflow on right hand side...
totalPhysMem *= memInfo.mem_unit;
Физическая память в настоящее время использовала:
Тот же код как в "Общей Виртуальной памяти" и затем
long long physMemUsed = memInfo.totalram - memInfo.freeram;
//Multiply in next statement to avoid int overflow on right hand side...
physMemUsed *= memInfo.mem_unit;
Физическая память, в настоящее время используемая текущим процессом:
Изменение getValue () в "Виртуальной памяти, в настоящее время используемой текущим процессом" следующим образом:
int getValue(){ //Note: this value is in KB!
FILE* file = fopen("/proc/self/status", "r");
int result = -1;
char line[128];
while (fgets(line, 128, file) != NULL){
if (strncmp(line, "VmRSS:", 6) == 0){
result = parseLine(line);
break;
}
}
fclose(file);
return result;
}
ЦП в настоящее время использовал:
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
void init(){
FILE* file = fopen("/proc/stat", "r");
fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,
&lastTotalSys, &lastTotalIdle);
fclose(file);
}
double getCurrentValue(){
double percent;
FILE* file;
unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;
file = fopen("/proc/stat", "r");
fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,
&totalSys, &totalIdle);
fclose(file);
if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||
totalSys < lastTotalSys || totalIdle < lastTotalIdle){
//Overflow detection. Just skip this value.
percent = -1.0;
}
else{
total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +
(totalSys - lastTotalSys);
percent = total;
total += (totalIdle - lastTotalIdle);
percent /= total;
percent *= 100;
}
lastTotalUser = totalUser;
lastTotalUserLow = totalUserLow;
lastTotalSys = totalSys;
lastTotalIdle = totalIdle;
return percent;
}
ЦП, в настоящее время используемый текущим процессом:
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "sys/times.h"
#include "sys/vtimes.h"
static clock_t lastCPU, lastSysCPU, lastUserCPU;
static int numProcessors;
void init(){
FILE* file;
struct tms timeSample;
char line[128];
lastCPU = times(&timeSample);
lastSysCPU = timeSample.tms_stime;
lastUserCPU = timeSample.tms_utime;
file = fopen("/proc/cpuinfo", "r");
numProcessors = 0;
while(fgets(line, 128, file) != NULL){
if (strncmp(line, "processor", 9) == 0) numProcessors++;
}
fclose(file);
}
double getCurrentValue(){
struct tms timeSample;
clock_t now;
double percent;
now = times(&timeSample);
if (now <= lastCPU || timeSample.tms_stime < lastSysCPU ||
timeSample.tms_utime < lastUserCPU){
//Overflow detection. Just skip this value.
percent = -1.0;
}
else{
percent = (timeSample.tms_stime - lastSysCPU) +
(timeSample.tms_utime - lastUserCPU);
percent /= (now - lastCPU);
percent /= numProcessors;
percent *= 100;
}
lastCPU = now;
lastSysCPU = timeSample.tms_stime;
lastUserCPU = timeSample.tms_utime;
return percent;
}
я принял бы, что часть кода Linux также работает на Unixe, за исключением частей, которые читают/proc псевдофайловую систему. Возможно, на Unix эти части могут быть заменены [1 118] и подобные функции? Если кто-то с ноу-хау Unix мог бы отредактировать этот ответ и заполнить детали?!
В Linux, эта информация доступна в/proc файловой системе. Я не большой поклонник используемого формата текстового файла, поскольку каждый дистрибутив Linux, кажется, настраивает по крайней мере один важный файл. Беглый взгляд как источник к 'PS' показывает путаницу.
, Но вот то, где найти информацию, Вы ищете:
/proc/meminfo содержит большинство информации в масштабе всей системы, которую Вы ищете. Здесь это похоже в моей системе; я думаю, что Вы интересуетесь [1 131] MemTotal, MemFree, SwapTotal, и SwapFree:
Anderson cxc # more /proc/meminfo
MemTotal: 4083948 kB
MemFree: 2198520 kB
Buffers: 82080 kB
Cached: 1141460 kB
SwapCached: 0 kB
Active: 1137960 kB
Inactive: 608588 kB
HighTotal: 3276672 kB
HighFree: 1607744 kB
LowTotal: 807276 kB
LowFree: 590776 kB
SwapTotal: 2096440 kB
SwapFree: 2096440 kB
Dirty: 32 kB
Writeback: 0 kB
AnonPages: 523252 kB
Mapped: 93560 kB
Slab: 52880 kB
SReclaimable: 24652 kB
SUnreclaim: 28228 kB
PageTables: 2284 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
CommitLimit: 4138412 kB
Committed_AS: 1845072 kB
VmallocTotal: 118776 kB
VmallocUsed: 3964 kB
VmallocChunk: 112860 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
Hugepagesize: 2048 kB
Для загрузки ЦП, необходимо сделать немного работы. Linux делает доступным полная загрузка ЦП, так как система запускается; это, вероятно, не то, чем Вы интересуетесь. Если Вы хотите знать то, чем загрузка ЦП была в течение прошлой секунды, или 10 секунд, то необходимо запросить информацию и вычислить ее сами.
информация доступна в [1 135]/proc/stat, который документируется вполне прилично в http://www.linuxhowtos.org/System/procstat.htm ; вот то, на что это похоже на моем поле с 4 ядрами:
Anderson cxc # more /proc/stat
cpu 2329889 0 2364567 1063530460 9034 9463 96111 0
cpu0 572526 0 636532 265864398 2928 1621 6899 0
cpu1 590441 0 531079 265949732 4763 351 8522 0
cpu2 562983 0 645163 265796890 682 7490 71650 0
cpu3 603938 0 551790 265919440 660 0 9040 0
intr 37124247
ctxt 50795173133
btime 1218807985
processes 116889
procs_running 1
procs_blocked 0
Первый, необходимо определить, сколько центральных процессоров (или процессоры или ядра обработки) доступно в системе. Чтобы сделать это, считайте количество 'cpuN' записей, где N запускается в 0 и инкременты. Не считайте строку 'CPU', которая является комбинацией cpuN строк. В моем примере Вы видите cpu0 через cpu3 для в общей сложности 4 процессоров. С этого времени можно проигнорировать cpu0.. cpu3 и внимание только на строку 'CPU'.
Затем, необходимо знать, что четвертое число в этих строках является мерой времени простоя, и таким образом четвертое число на строке 'CPU' является общим временем простоя для всех процессоров со времени начальной загрузки. Это время измеряется в Linux "миг", который является 1/100 секунды каждый.
, Но Вы не заботитесь в общее время простоя; Вы заботитесь во время простоя в установленный срок, например, в последнюю секунду. Действительно вычислите, что, необходимо считать этот файл дважды, 1 секунда независимо. Тогда можно сделать разность четвертого значения строки. Например, если Вы берете образец и добираетесь:
cpu 2330047 0 2365006 1063853632 9035 9463 96114 0
Тогда одну секунду спустя Вы получаете этот образец:
cpu 2330047 0 2365007 1063854028 9035 9463 96114 0
Вычитают эти два числа, и Вы получаете разность 396, что означает, что Ваш ЦП был неактивен в течение 3,96 секунд из прошлых 1,00 секунд. Прием, конечно, то, что необходимо разделиться на количество процессоров. 3.96 / 4 = 0.99, и существует Ваш неактивный процент; неактивных 99%, и занятый 1%.
В моем коде, у меня есть кольцевой буфер 360 записей, и я читал этот файл каждую секунду. Это позволяет мне быстро вычислить загрузку ЦП на 1 секунду, 10 секунд, и т.д., полностью до 1 часа.
Для определенной для процесса информации, необходимо посмотреть в [1 136]/proc/pid; если Вы не заботитесь, примыкают к Вашему изодромному с предварением, можно посмотреть в/proc/self.
ЦП, используемый Вашим процессом, доступен в [1 137]/proc/self/stat. Это - нечетно выглядящий файл, состоящий из одной строки; например:
19340 (whatever) S 19115 19115 3084 34816 19115 4202752 118200 607 0 0 770 384 2
7 20 0 77 0 266764385 692477952 105074 4294967295 134512640 146462952 321468364
8 3214683328 4294960144 0 2147221247 268439552 1276 4294967295 0 0 17 0 0 0 0
важные данные здесь являются 13-ми и 14-ми маркерами (0 и 770 здесь). 13-й маркер является количеством мига, который процесс выполнил в непривилегированном режиме, и 14-м является количество мига, который процесс выполнил в привилегированном режиме. Добавьте два вместе, и у Вас есть его суммарное использование ЦП.
Снова, необходимо будет периодически выбирать этот файл и вычислять разность для определения использования ЦП процесса со временем.
Редактирование: помнят, что при вычислении загрузки ЦП процесса необходимо принять во внимание 1) количество потоков в процессе и 2) количество процессоров в системе. Например, если Ваш однопоточный процесс использует только 25% ЦП, который мог бы быть хорошим или плохим. Хороший в однопроцессорной системе, но плохо в системе с 4 процессорами; это означает, что Ваш процесс работает постоянно и использует 100% циклов ЦП, доступных ему.
Для определенной для процесса информации о памяти, Вы ahve для рассмотрения/proc/self/status, который похож на это:
Name: whatever
State: S (sleeping)
Tgid: 19340
Pid: 19340
PPid: 19115
TracerPid: 0
Uid: 0 0 0 0
Gid: 0 0 0 0
FDSize: 256
Groups: 0 1 2 3 4 6 10 11 20 26 27
VmPeak: 676252 kB
VmSize: 651352 kB
VmLck: 0 kB
VmHWM: 420300 kB
VmRSS: 420296 kB
VmData: 581028 kB
VmStk: 112 kB
VmExe: 11672 kB
VmLib: 76608 kB
VmPTE: 1244 kB
Threads: 77
SigQ: 0/36864
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: fffffffe7ffbfeff
SigIgn: 0000000010001000
SigCgt: 20000001800004fc
CapInh: 0000000000000000
CapPrm: 00000000ffffffff
CapEff: 00000000fffffeff
Cpus_allowed: 0f
Mems_allowed: 1
voluntary_ctxt_switches: 6518
nonvoluntary_ctxt_switches: 6598
записи, которые запускаются с 'Vm', являются интересными:
единственный объект, в котором я не уверен, Область подкачки, в настоящее время используемая моим процессом . Я не знаю, доступно ли это.
Я надеялся найти аналогичную информацию и для Mac OS X. Поскольку его здесь не было, я сам пошел и откопал его. Вот некоторые вещи, которые я нашел. Если у кого-то есть другие предложения, я хотел бы их услышать.
Это сложно для Mac OS X, потому что в нем не используется предварительно установленный раздел подкачки или файл, как в Linux. Вот запись из документации Apple:
Примечание: В отличие от большинства операционных систем на базе Unix, Mac OS X не использует предварительно выделенный раздел подкачки для виртуальной памяти. Вместо этого он использует все доступное пространство в загрузочном разделе машины.
Итак, если вы хотите знать, сколько виртуальной памяти все еще доступно, вам нужно получить размер корневого раздела. Сделать это можно так:
struct statfs stats;
if (0 == statfs("/", &stats))
{
myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}
Вызов systcl с ключом «vm.swapusage» предоставляет интересную информацию об использовании подкачки:
sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M used = 2511.78M free = 560.22M (encrypted)
Не то, чтобы отображаемое здесь общее использование подкачки могло измениться, если потребуется больше подкачки, как описано в разделе над. Таким образом, общая сумма фактически равна текущей сумме свопа. В C ++ эти данные могут быть запрошены следующим образом:
xsw_usage vmusage = {0};
size_t size = sizeof(vmusage);
if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 )
{
perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" );
}
Обратите внимание, что «xsw_usage», объявленный в sysctl.h, не задокументирован, и я подозреваю, что существует более переносимый способ доступа к этим значениям.
Вы можете получить статистику о вашем текущем процессе с помощью функции task_info
. Это включает в себя текущий размер резидента вашего процесса и текущий виртуальный размер.
#include<mach/mach.h>
struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
if (KERN_SUCCESS != task_info(mach_task_self(),
TASK_BASIC_INFO, (task_info_t)&t_info,
&t_info_count))
{
return -1;
}
// resident size is in t_info.resident_size;
// virtual size is in t_info.virtual_size;
Объем физической оперативной памяти, доступной в вашей системе, можно получить с помощью системной функции sysctl
следующим образом:
#include <sys/types.h>
#include <sys/sysctl.h>
...
int mib[2];
int64_t physical_memory;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);
Вы можете получить общую статистику памяти из системная функция host_statistics
.
#include <mach/vm_statistics.h>
#include <mach/mach_types.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>
int main(int argc, const char * argv[]) {
vm_size_t page_size;
mach_port_t mach_port;
mach_msg_type_number_t count;
vm_statistics64_data_t vm_stats;
mach_port = mach_host_self();
count = sizeof(vm_stats) / sizeof(natural_t);
if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
(host_info64_t)&vm_stats, &count))
{
long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;
long long used_memory = ((int64_t)vm_stats.active_count +
(int64_t)vm_stats.inactive_count +
(int64_t)vm_stats.wire_count) * (int64_t)page_size;
printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);
}
return 0;
}
Следует отметить, что в Mac OS X существует пять типов страниц памяти. Они следующие:
Приятно отметить, что только потому, что Mac OS X может показывать очень мало фактической свободной памяти в раз, что это не может быть хорошим показателем того, сколько из них готово к использованию в короткие сроки.
См. «Виртуальная память, в настоящее время используется моим процессом» выше. Применяется тот же код.
Приятно отметить, что только потому, что Mac OS X может иногда показывать очень мало фактической свободной памяти, это не может быть хорошим показателем того, какой объем готов к использованию в короткие сроки.
См. выше «Виртуальная память, используемая моим процессом». Применяется тот же код.
Приятно отметить, что только потому, что Mac OS X может иногда показывать очень мало фактической свободной памяти, это не может быть хорошим показателем того, какой объем готов к использованию в короткие сроки.
См. выше «Виртуальная память, используемая моим процессом». Применяется тот же код.