// Конструирует объект типа DELTA_METHOD с заданными параметрами упаковки
// или возвращает NULL, если это другой метод сжатия или допущена ошибка в параметрах
COMPRESSION_METHOD* parse_DELTA (char** parameters)
{
if (strcmp (parameters[0], "delta") == 0) {
// Если название метода (нулевой параметр) - "delta", то разберём остальные параметры
DELTA_METHOD *p = new DELTA_METHOD;
int error = 0; // Признак того, что при разборе параметров произошла ошибка
// Переберём все параметры метода (или выйдем раньше при возникновении ошибки при разборе очередного параметра)
while (*++parameters && !error)
{
char* param = *parameters;
if (strlen(param)==1) switch (*param) { // Однобуквенные параметры
case 'x': p->ExtendedTables = 1; continue;
}
switch (*param) { // Параметры, содержащие значения
case 'b': p->BlockSize = parseMem (param+1, &error); continue;
}
// Сюда мы попадаем, если в параметре не указано его название
// Если этот параметр удастся разобрать как объём памяти,
// то присвоим его значение полю BlockSize
p->BlockSize = parseMem (param, &error);
}
if (error) {delete p; return NULL;} // Ошибка при парсинге параметров метода
return p;
} else
return NULL; // Это не метод DELTA
}
// Конструирует объект типа DICT_METHOD с заданными параметрами упаковки
// или возвращает NULL, если это другой метод сжатия или допущена ошибка в параметрах
COMPRESSION_METHOD* parse_DICT (char** parameters)
{
if (strcmp (parameters[0], "dict") == 0) {
// Если название метода (нулевой параметр) - "dict", то разберём остальные параметры
DICT_METHOD *p = new DICT_METHOD;
int error = 0; // Признак того, что при разборе параметров произошла ошибка
// Переберём все параметры метода (или выйдем раньше при возникновении ошибки при разборе очередного параметра)
while (*++parameters && !error)
{
char* param = *parameters;
if (strlen(param)==1) switch (*param) { // Однобуквенные параметры
case 'p': p->MinLargeCnt=8192; p->MinMediumCnt=400; p->MinSmallCnt=100; p->MinRatio=4; continue;
case 'f': p->MinLargeCnt=2048; p->MinMediumCnt=100; p->MinSmallCnt= 50; p->MinRatio=0; continue;
}
else switch (*param) { // Параметры, содержащие значения
case 'b': p->BlockSize = parseMem (param+1, &error); continue;
case 'c': p->MinWeakChars = parseInt (param+1, &error); continue;
case 'l': p->MinLargeCnt = parseInt (param+1, &error); continue;
case 'm': p->MinMediumCnt = parseInt (param+1, &error); continue;
case 's': p->MinSmallCnt = parseInt (param+1, &error); continue;
case 'r': p->MinRatio = parseInt (param+1, &error); continue;
}
// Если параметр заканчивается знаком процента. то попробуем распарсить его как "N%"
if (last_char(param) == '%') {
char str[100]; strcpy(str,param); last_char(str) = '\0';
int n = parseInt (str, &error);
if (!error) { p->MinCompression = n; continue; }
error=0;
}
// Сюда мы попадаем, если в параметре не указано его название
// Если этот параметр удастся разобрать как целое число (т.е. в нём - только цифры),
// то присвоим его значение полю MinMatchLen, иначе попробуем разобрать его как BlockSize
int n = parseInt (param, &error);
if (!error) p->MinWeakChars = n;
else error=0, p->BlockSize = parseMem (param, &error);
}
if (error) {delete p; return NULL;} // Ошибка при парсинге параметров метода
return p;
} else
return NULL; // Это не метод DICT
}
// Конструирует объект типа REP_METHOD с заданными параметрами упаковки
// или возвращает NULL, если это другой метод сжатия или допущена ошибка в параметрах
COMPRESSION_METHOD* parse_REP (char** parameters)
{
if (strcmp (parameters[0], "rep") == 0) {
// Если название метода (нулевой параметр) - "rep", то разберём остальные параметры
REP_METHOD *p = new REP_METHOD;
int error = 0; // Признак того, что при разборе параметров произошла ошибка
// Переберём все параметры метода (или выйдем раньше при возникновении ошибки при разборе очередного параметра)
while (*++parameters && !error)
{
char* param = *parameters;
switch (*param) { // Параметры, содержащие значения
case 'b': p->BlockSize = parseMem (param+1, &error); continue;
case 'l': p->MinMatchLen = parseInt (param+1, &error); continue;
case 'd': p->Barrier = parseMem (param+1, &error); continue;
case 's': p->SmallestLen = parseInt (param+1, &error); continue;
case 'h': p->HashSizeLog = parseInt (param+1, &error); continue;
case 'a': p->Amplifier = parseInt (param+1, &error); continue;
}
// Если параметр заканчивается знаком процента. то попробуем распарсить его как "N%"
if (last_char(param) == '%') {
char str[100]; strcpy(str,param); last_char(str) = '\0';
int n = parseInt (str, &error);
if (!error) { p->MinCompression = n; continue; }
error=0;
}
// Сюда мы попадаем, если в параметре не указано его название
// Если этот параметр удастся разобрать как целое число (т.е. в нём - только цифры),
// то присвоим его значение полю MinMatchLen, иначе попробуем разобрать его как BlockSize
int n = parseInt (param, &error);
if (!error) p->MinMatchLen = n;
else error=0, p->BlockSize = parseMem (param, &error);
}
if (error) {delete p; return NULL;} // Ошибка при парсинге параметров метода
return p;
} else
return NULL; // Это не метод REP
}
ExpPtr parseTermPostfix (Lexer& lex, ExpPtr in)
{
for (;;)
switch (lex.current().tok)
{
case tLParen:
in = parseCall(lex, in);
break;
case tDot:
in = parseMem(lex, in);
break;
default:
return in;
}
}
void parseArgs(char *arg, int iType,char * code, int curIndex) {
char *p;
p = arg;
while (isspace(*p)) {
p++;
}
if(iType == TYPE_R) {
p = getReg(code, p, REG_D);
while (isspace(*p)) {
p++;
}
p = getReg(code, p, REG_S);
while (isspace(*p)) {
p++;
}
p = getReg(code, p, REG_T);
} else if(iType == TYPE_JR) {
p = getReg(code, p, REG_S);
} else if(iType == TYPE_I) {
p = getReg(code, p, REG_S);
while (isspace(*p)) {
p++;
}
p = getReg(code, p, REG_T);
while (isspace(*p)) {
p++;
}
getImmediate(code, p, curIndex);
} else if(iType == TYPE_J) {
while (isspace(*p)) {
p++;
}
getImmediate(code, p, -1);
} else if(iType == TYPE_LS) {
p = getReg(code, p, REG_T);
while (isspace(*p)) {
p++;
}
parseMem(p, code);
} else {
fprintf(stderr, "DiE IDE DIE\n");
exit(1);
}
}
void method()
{
//wifi
if(network==1)
{
sprintf(path_tx,"/sys/class/net/wlan0/statistics/tx_packets");
sprintf(path_rx,"/sys/class/net/wlan0/statistics/rx_packets");
sprintf(path_oper,"/sys/class/net/wlan0/operstate");
}
//3G
else if(network==0)
{
sprintf(path_tx,"/sys/class/net/rmnet0/statistics/tx_packets");
sprintf(path_rx,"/sys/class/net/rmnet0/statistics/rx_packets");
sprintf(path_oper,"/sys/class/net/rmnet0/operstate");
}
isRunOnce = 1;
size = nRows;
samples = (char **)malloc(nRows * sizeof(char *));
int c2=0;
for(c2=0; c2<nRows; c2++)
samples[c2] = (char *) malloc(numCol * sizeof(char));
printf("test passed2\n");
SPVRScopeImplData *psData;
//Counter information (set at init time)
SPVRScopeCounterDef *psCounters;
unsigned int uCounterNum;
//Counter reading data
unsigned int uActiveGroup;
unsigned int uActiveGroupSelect;
bool bActiveGroupChanged;
SPVRScopeCounterReading sReading;
// Step 2. Initialise PVRScopeStat
if (PSInit(&psData, &psCounters, &sReading, &uCounterNum)){
//LOGI("PVRScope up and running.");
printf("PVRScore up and running...\n");
/*sprintf(aut,"%s\n","su");
system(aut);*/
}else{
//LOGE("Error initializing PVRScope.");
printf("Error initializing PVRScope...\n");
}
bActiveGroupChanged = true;
uActiveGroupSelect = 0;
unsigned int sampleRate = delay;
unsigned int index = 0;
unsigned int j = 0;
unsigned int k = 0;
struct timeval tv_start;
gettimeofday(&tv_start, NULL);
unsigned long time_in_sec_start = tv_start.tv_sec;
printf("Begin working...\n");
/*
strcat(header,"Start_time(second)=");
char startTime[1024];
snprintf(startTime,1024,"%lu\n",time_in_sec_start);
strcat(header,startTime);
strcat(header,"delay=");
char delayData[50];
snprintf(delayData,50,"%d\n",delay);
strcat(header,delayData);
*/
int startIndex = 0;
while (startIndex < nRows)
{
// Ask for the active group 0 only on the first run. Then set it to 0xffffffff
if(bActiveGroupChanged)
{
uActiveGroup = uActiveGroupSelect;
}
else
{
uActiveGroup = 0xffffffff;
}
++index;
if (index < 100)
{
// Sample the counters every 10ms. Don't read or output it.
PVRScopeReadCountersThenSetGroup(psData, NULL, 0, uActiveGroup);
}
else
{
if(k < delay)
{
++k;
index = 0;
//continue;
}
else
{
k = 0;
index = 0;
printf("sample %d\n", startIndex);
struct timeval tv;
gettimeofday(&tv, NULL);
unsigned long time_in_mill = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
// Step 4. Read and output the counter information for group 0 to Logcat
if(PVRScopeReadCountersThenSetGroup(psData, &sReading, time_in_mill * 1000, uActiveGroup))
{
printf("Start sample\n");
strcat(header,"\n_LOOP_");
char loop[50];
snprintf(loop, 50, "%d\n", startIndex);
strcat(header,loop);
/*if(startIndex == 10){
setState(2);
}
else if(startIndex == 15){
setState(5);
}*/
//Read bigLittle_status
if((fp_cpu = fopen("su -c /dev/bL_status","r")) != NULL)
{
printf("bl\n");
strcat(header,"_BL_\n");
fgets(buffer,sizeof buffer, fp_cpu);
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,buffer);
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp_cpu);
}
strcat(header,"_CPU_\n");
if((fp_cpu = fopen("/proc/stat","r")) != NULL)
{
fgets(buffer,sizeof buffer, fp_cpu);
//CPU0
fgets(buffer,sizeof buffer, fp_cpu);
double cpu_util = parseCPU(buffer,0);
char output[50];
snprintf(output,50,"util=%.2f",cpu_util);
strcat(header,output);
printf("cpu0 util = %s \n",header);
memset(buffer, 0, sizeof(buffer));
memset(output, 0, sizeof(output));
if((fp_cpu_chk = fopen("/sys/devices/system/cpu/cpu1/online","r")) != NULL)
{
char test[50];
fgets(test, sizeof test, fp_cpu_chk);
if(atoi(test) == 1)
{
fgets(buffer,sizeof buffer, fp_cpu);
cpu_util = parseCPU(buffer,1);
snprintf(output,50," %.2f",cpu_util);
strcat(header,output);
memset(buffer, 0, sizeof(buffer));
memset(output, 0, sizeof(output));
//fclose(fp_cpu);
}
else
{
strcat(header," x");
}
fclose(fp_cpu_chk);
}
if((fp_cpu_chk = fopen("/sys/devices/system/cpu/cpu2/online","r")) != NULL)
{
char test[50];
fgets(test, sizeof test, fp_cpu_chk);
if(atoi(test) == 1)
{
fgets(buffer,sizeof buffer, fp_cpu);
cpu_util = parseCPU(buffer,2);
snprintf(output,50," %.2f",cpu_util);
strcat(header,output);
memset(buffer, 0, sizeof(buffer));
memset(output, 0, sizeof(output));
//fclose(fp_cpu);
}
else
{
strcat(header," x");
//printf(" x");
}
fclose(fp_cpu_chk);
}
if((fp_cpu_chk = fopen("/sys/devices/system/cpu/cpu3/online","r")) != NULL)
{
char test[50];
fgets(test, sizeof test, fp_cpu_chk);
if(atoi(test) == 1)
{
fgets(buffer,sizeof buffer, fp_cpu);
cpu_util = parseCPU(buffer,3);
snprintf(output,50," %.2f",cpu_util);
strcat(header,output);
memset(buffer, 0, sizeof(buffer));
memset(output, 0, sizeof(output));
//fclose(fp_cpu);
}
else
{
strcat(header," x");
//printf("last x\n");
}
fclose(fp_cpu_chk);
}
fclose(fp_cpu);
}
strcat(header,"\n_FREQ_");
//Read freq0
if((fp_cpu = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq","r")) != NULL)
{
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,"\nfreq0=");
strcat(header,buffer);
//printf("%s\n",header);
memset(buffer, 0, sizeof(buffer));
fclose(fp_cpu);
}
//Read freq1
if((fp_cpu = fopen("/sys/devices/system/cpu/cpu1/cpufreq/scaling_cur_freq","r")) != NULL)
{
//printf("freq1\n");
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,"freq1=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp_cpu);
}
else
{
strcat(header,"freq1=x");
//printf("freq1=x");
}
//Read freq2
if((fp_cpu = fopen("/sys/devices/system/cpu/cpu2/cpufreq/scaling_cur_freq","r")) != NULL) {
//printf("freq2\n");
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,"freq2=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp_cpu);
}
else
{
strcat(header,"\nfreq2=x");
//printf("\nfreq2=x");
}
//Read freq3
if((fp_cpu = fopen("/sys/devices/system/cpu/cpu3/cpufreq/scaling_cur_freq","r")) != NULL) {
//printf("freq3\n");
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header,"freq3=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp_cpu);
}
else
{
strcat(header,"\nfreq3=x");
//printf("\nfreq3=x");
}
//printf("%s\n",header);
//Read CPU idle time C0S0IT //////////////////////////////////////////////////////////////////////////
strcat(header,"\n_IDLE_TIME_\n");
//printf("idle time\n");
for(int core=0; core<4; core++)
{
char title[100];
snprintf(title,100,"idle_time_%d=",core);
strcat(header,title);
for(int state=0; state<3; state++)
{
char proc[100];
sprintf(proc,"/sys/devices/system/cpu/cpu%d/cpuidle/state%d/time",core,state);
if((fp_cpu = fopen(proc,"r")) != NULL)
{
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header," ");
double cur = atof(buffer);
double diff_time = cur - csit[core][state];
char output_idle[50];
snprintf(output_idle,50,"%.2f",diff_time/1000);
strcat(header,output_idle);
memset(buffer, 0, sizeof(buffer));
csit[core][state] = cur;
fclose(fp_cpu);
}
else{
strcat(header," x");
}
}
strcat(header,"\n");
}
strcat(header,"_IDLE_USAGE_\n");
for(int core=0; core<4; core++)
{
char title[100];
snprintf(title,100,"idle_usage_%d=",core);
strcat(header,title);
for(int state=0; state<3; state++)
{
char proc[100];
sprintf(proc,"/sys/devices/system/cpu/cpu%d/cpuidle/state%d/usage",core,state);
if((fp_cpu = fopen(proc,"r")) != NULL)
{
fgets(buffer,sizeof buffer, fp_cpu);
strcat(header," ");
int cur = atoi(buffer);
int diff_entry = cur - csiu[core][state];
char output_entry[50];
snprintf(output_entry,50,"%d",diff_entry);
strcat(header,output_entry);
memset(buffer, 0, sizeof(buffer));
csiu[core][state] = cur;
fclose(fp_cpu);
}
else{
strcat(header," x");
}
}
strcat(header,"\n");
}
///////////////////////// Read memory usage /////////////////////////////////////////
strcat(header,"_MEM_\n");
//if((fp = fopen("/data/local/tmp/busybox free -m", "r")) != NULL)
if((fp_mem = fopen("/proc/meminfo","r")) != NULL)
{
//printf("mem\n");
fgets(buffer, sizeof buffer, fp_mem);
//printf("buffer = %s\n",buffer);
strcat(header,"mem=");
char buffer2[1024];
char buffer3[1024];
fgets(buffer2, sizeof buffer, fp_mem);
fgets(buffer3, sizeof buffer, fp_mem);
double mem_util = parseMem(buffer, buffer2, buffer3);
char output[50];
snprintf(output,50,"%.2f",mem_util);
strcat(header,output);
memset(buffer, 0, sizeof(buffer));
memset(buffer2, 0, sizeof(buffer2));
memset(buffer3, 0, sizeof(buffer3));
fclose(fp_mem);
}
strcat(header,"\n_DISPLAY_");
//Read bright
//Nexus ("/sys/class/backlight/s5p_bl/brightness")
if((fp = fopen("/sys/class/backlight/panel/brightness","r")) != NULL) {
//printf("brightness\n");
fgets(buffer,sizeof buffer, fp);
//sprintf(header,"\n_DISPLAY_\n%s","bright=");
strcat(header,"\nbright=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
if((fp = fopen("/sys/class/backlight/s5p_bl/brightness","r")) != NULL) {
//printf("brightness\n");
fgets(buffer,sizeof buffer, fp);
//sprintf(header,"\n_DISPLAY_\n%s","bright=");
strcat(header,"\nbright=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
strcat(header,"_WIFI_\n");
//wifi
if((fp = fopen(path_tx,"r")) != NULL) {
//printf("WiFi\n");
fgets(buffer,sizeof buffer, fp);
double cur = atof(buffer);
double diff_tx = cur - prev_tx;
char output_tx[50];
snprintf(output_tx,50,"%.2f",diff_tx);
strcat(header,"tx=");
strcat(header,output_tx);
memset(buffer, 0, sizeof(buffer));
prev_tx = cur;
fclose(fp);
}
else{
strcat(header,"tx=0");
}
if((fp = fopen(path_rx,"r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
double cur = atof(buffer);
double diff_rx = cur - prev_rx;
char output_rx[50];
snprintf(output_rx,50,"%.2f",diff_rx);
strcat(header,"\nrx=");
strcat(header,output_rx);
memset(buffer, 0, sizeof(buffer));
prev_rx = cur;
fclose(fp);
}
else{
strcat(header,"\nrx=0");
}
if((fp = fopen(path_oper,"r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
strcat(header,"\noperstate=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
else{
strcat(header,"\noperstate=0");
}
//Battery
strcat(header,"\n_BATTERY_\n");
if((fp = fopen("/sys/class/power_supply/battery/voltage_now","r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
strcat(header,"batt_volt=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
if((fp = fopen("/sys/class/power_supply/battery/current_now","r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
strcat(header,"batt_current=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
if((fp = fopen("/sys/class/power_supply/battery/capacity","r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
strcat(header,"batt_capacity=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
if((fp = fopen("/sys/class/power_supply/battery/temp","r")) != NULL) {
fgets(buffer,sizeof buffer, fp);
strcat(header,"batt_temperature=");
strcat(header,buffer);
memset(buffer, 0, sizeof(buffer));
fclose(fp);
}
// Check for all the counters in the system if the counter has a value on the given active group and ouptut it.
strcat(header,"_GPU_\n");
for(int p = 0; p < uCounterNum; ++p)
{
if(p < sReading.nValueCnt)
{
strcat(header,psCounters[p].pszName);
strcat(header,"=");
char params[50];
snprintf(params,50,"%.2f\n",sReading.pfValueBuf[p]);
strcat(header, params);
//memset(buffer, 0, sizeof(buffer));
}
}
}
strcpy(samples[startIndex],header);
printf("%s\n",samples[startIndex]);
memset(header, 0, sizeof(header));
//realloc
/*if(j == nRows-1)
{
samples = (char **)realloc(samples, (nRows + size) * sizeof(char *));
int s=0;
nRows = nRows + size;
for(s=j+1; s<nRows; s++)
samples[s] = (char *) malloc(numCol * sizeof(char));
}
++j;
cur_cap = getCap();
*/
++startIndex;
//printf("Current start index = %d num of rows = %d \n", startIndex, nRows);
printf("End_loop %d\n", startIndex);
}
}
//Poll for the counters once a second
usleep(10000);
//usleep(1000000);
}
// Step 5. Shutdown PVRScopeStats
PVRScopeDeInitialise(&psData, &psCounters, &sReading);
struct timeval tv_stop;
gettimeofday(&tv_stop, NULL);
unsigned long time_in_sec_stop = tv_stop.tv_sec;
char endTime[1024];
snprintf(endTime,1024,"%lu\n",time_in_sec_stop);
char elapseTime[1024];
snprintf(elapseTime,1024,"%lu\n",(time_in_sec_stop - time_in_sec_start)/60);
printf("Save file\n");
sprintf(saveFile,"/data/local/tmp/stat/sample%d.txt", fileIndex);
fp_save = fopen(saveFile,"w+");
for(int i = 0; i < nRows; i++)
{
//printf("%s",samples[i]);
fprintf(fp_save, "%s", samples[i]);
}
fprintf(fp_save, "%s\n",endTime);
//fprintf(fp_save, "Use time(min)=%s",elapseTime);
printf("close all file\n");
fclose(fp_save);
printf("end file\n");
//Clear array memory
//sample is a heap data structure
free(samples);
memset(saveFile, 0, sizeof(saveFile));
memset(prev_total, 0, sizeof(prev_total));
memset(prev_idle, 0, sizeof(prev_idle));
memset(csit, 0, sizeof(csit));
memset(csiu, 0, sizeof(csiu));
prev_tx = 0;
prev_rx = 0;
printf("clear file\n");
exit(0);
}
