GPM合并资料整理-GEM部分

已于 2024-01-10 12:13:33 修改
阅读量648 收藏 8
点赞数 11
分类专栏： iOS 文章标签： cocoa macos objective-c
于 2024-01-10 12:09:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoshuangxiaodouya/article/details/135500272
版权

一、性能数据上报项

1. CPU模块

上报键值说明采集平台
cpu当前进程cpu使用率平均值Android & iOS
totcpu系统cpu总使用率平均值Android & iOS
cpu_temp_maxcpu最高温度Android
cpu_temp_avgcpu温度平均值Android
gpu_temp_avggpu温度平均值Android
gpu_temp_maxgpu最高温度Android
gpugpu使用率平均值Android
gpu_modelgpu型号Android
cpu_modelcpu型号Android
cpu_corecpu核心数Android
cpu_freqcpu最大时钟频率Android

2. memory及存储模块

上报键值说明采集平台
mem当前进程内存使用量平均值Android & iOS
availmem当前设备可用内存量平均值Android & iOS
max_mem内存使用量最大值Android & iOS
start_mem开始对局时内存使用量Android & iOS
end_mem结束对局时内存使用量Android & iOS
totalmem当前设备总内存量Android & iOS
total_storage当前设备总存储空间大小Android & iOS
free_storage当前设备可用存储空间大小Android & iOS

3. 网卡模块

上报键值说明采集平台
wsndpkt无线网卡发包总数Android & iOS
wrcvpkt无线网卡收包总数Android & iOS
wsnddrop无线网卡发包丢包Android & iOS
wrcvdrop无线网卡收包丢包Android & iOS
wsnderr无线网卡发包错包Android & iOS
wrcverr无线网卡收包错包Android & iOS
msndpkt移动网卡发包总数Android & iOS
mrcvpkt移动网卡收包总数Android & iOS
msnddrop移动网卡发包丢包Android & iOS
mrcvdrop移动网卡收包丢包Android & iOS
msnderr移动网卡发包错包Android & iOS
mrcverr移动网卡收包错包Android & iOS

4. FPS模块

上报键值说明采集平台
fminfps最小值Android & iOS
fmaxfps最大值Android & iOS
favgfps平均值Android & iOS
fheavyfps严重抖动个数（本次fps值比上次fps值低10以上）Android & iOS
flightfps轻微抖动个数（本次fps值比上次fps值低4以上，10以下）Android & iOS
ftotalfps采集总个数Android & iOS
fcntx0fps自定义抖动个数（阈值由云控下发）Android & iOS
lfps1低于云控下发的lfps1阈值的个数Android & iOS
lfps2低于云控下发的lfps2阈值的个数Android & iOS
lfps3低于云控下发的lfps3阈值的个数Android & iOS

5. 电量模块

上报键值说明采集平台
battery电量消耗（开始-结束）Android & iOS
start_battery开始对局时电量值Android & iOS
end_battery结束对局时电量值Android & iOS
bs对局过程中是否有充电操作Android & iOS
bt电池温度平均值Android
max_battery_temp电池温度最大值Android

6. 网络相关模块

上报键值说明采集平台
netflow流量消耗Android & iOS
devices当前wifi下连接设备数Android & iOS
wifi_numwifi个数Android
wifi_rssi当前wifi信号强度Android
wifi_speed当前wifi链接速度Android
gate_delay到网关延迟（ping）Android & iOS
signal_level移动信号强度Android
xg当前网络类型Android & iOS
ldns本机DNS服务器Android & iOS

7. 机型相关

上报键值说明采集平台
manufacturer厂商Android
brand品牌Android
model型号Android
resolution分辨率Android

cpu&memory采集具体实现代码

1. cpu

  • Android采集代码：

      public static float totalCpuUsageRate() {
  	return getTotalCpuUsageRate(USAGE_RATE_CAL_INTERVAL_MILLS_DEFAULT);
  }

  public static float getTotalCpuUsageRate(long calIntervalMills) {
  	if (0 > calIntervalMills) {
  		return VALUE_GET_FAILED;
  	}
  	float totalCpuUsageRate = VALUE_GET_FAILED;
  	try {
  		TotalCpuStatInfo totalCpuStatInfo1 = TotalCpuStatInfo.get();
  		long cpuTotal1 = totalCpuStatInfo1.getCpuTotal();
  		if (0 > cpuTotal1) {
  			return totalCpuUsageRate;
  		}
  		long total1 = totalCpuStatInfo1.getTotal();
  		if (0 > total1) {
  			return totalCpuUsageRate;
  		}
  		try {
  			Thread.sleep(calIntervalMills);
  		} catch (Exception e) {
  			GPMLogger.w(e, "getTotalCpuUsageRate failed");
  		}
  		TotalCpuStatInfo totalCpuStatInfo2 = TotalCpuStatInfo.get();
  		long cpuTotal2 = totalCpuStatInfo2.getCpuTotal();
  		if (0 > cpuTotal2) {
  			return totalCpuUsageRate;
  		}
  		long total2 = totalCpuStatInfo2.getTotal();
  		if (0 > total2) {
  			return totalCpuUsageRate;
  		}
  		long totalDiff = total2 - total1;
  		if (0 == totalDiff) {
  			// NOTE: totalDiff为分母
  			return totalCpuUsageRate;
  		}
  		long cpuTotalDiff = cpuTotal2 - cpuTotal1;
  		return 100 * cpuTotalDiff / (totalDiff + 0f);
  	} catch (Exception e) {
  		GPMLogger.w(e, "getTotalCpuUsageRate failed");
  	}
  		return totalCpuUsageRate;
  	}

  public static float myCpuUsageRate() {
  	return getMyCpuUsageRate(USAGE_RATE_CAL_INTERVAL_MILLS_DEFAULT);
  }

  public static float getMyCpuUsageRate(long calIntervalMills) {
  	if (0 > calIntervalMills) {
  		return VALUE_GET_FAILED;
  	}
  	float myCpuUsageRate = VALUE_GET_FAILED;
  	try {
  		TotalCpuStatInfo totalCpuStatInfo1 = TotalCpuStatInfo.get();
  		long total1 = totalCpuStatInfo1.getTotal();
  		if (0 > total1) {
  			return myCpuUsageRate;
  		}
  		MyCpuStatInfo myCpuStatInfo1 = MyCpuStatInfo.get();
  		long myCpuTotal1 = myCpuStatInfo1.getCpuTotal();
  		if (0 > myCpuTotal1) {
  			return myCpuUsageRate;
  		}
  		try {
  			Thread.sleep(calIntervalMills);
  		} catch (Exception e) {
  			GPMLogger.w(e, "getMyCpuUsageRate failed");
  		}
  		TotalCpuStatInfo totalCpuStatInfo2 = TotalCpuStatInfo.get();
  		long total2 = totalCpuStatInfo2.getTotal();
  		if (0 > total2) {
  			return myCpuUsageRate;
  		}
  		MyCpuStatInfo myCpuStatInfo2 = MyCpuStatInfo.get();
  		long myCpuTotal2 = myCpuStatInfo2.getCpuTotal();
  		if (0 > myCpuTotal2) {
  			return myCpuUsageRate;
  		}
  		long totalDiff = total2 - total1;
  		if (0 == totalDiff) {
  			// NOTE: totalDiff为分母
  			return myCpuUsageRate;
  		}
  		long myCpuTotalDiff = myCpuTotal2 - myCpuTotal1;
  		return 100 * myCpuTotalDiff / (totalDiff + 0f);
  	} catch (Exception e) {
  		GPMLogger.w(e, "getTotalCpuUsageRate failed");
  	}
  	return myCpuUsageRate;
  }

  private static class TotalCpuStatInfo {
  	private static final int MIN_CPU_STAT_ITEM_NUM = 9;
  	private static final String[] INVALID_RAW_CPU_STAT_ITEMS =
          new String[MIN_CPU_STAT_ITEM_NUM];

  	public final long user;
  	public final long nice;
  	public final long system;
  	public final long idle;
  	public final long iowait;
  	public final long irq;
  	public final long softirq;

  	public static TotalCpuStatInfo get() {
  		BufferedReader cpuStatInfoReader = null;
  		try {
  			cpuStatInfoReader = new BufferedReader(new InputStreamReader(new FileInputStream(STAT_ABS_DIR), UTF8_CHARSET));
  			return new TotalCpuStatInfo(cpuStatInfoReader.readLine());
  		} catch (Exception e) {
  			// NOTE: 高版本上获取不到, 不打印堆栈
  			GPMLogger.d("get total cpu stat info failed");
  			return new TotalCpuStatInfo(null);
  		} finally {
  			if (null != cpuStatInfoReader) {
  				try {
  					cpuStatInfoReader.close();
  				} catch (IOException ignored) {
  				}
  			}
  		}
  	}

  	private TotalCpuStatInfo(String cpuStatLine) {
  		String[] rawCpuStatItems = CpuStatInfoHelper.buildRawCpuStatItems(cpuStatLine, MIN_CPU_STAT_ITEM_NUM, INVALID_RAW_CPU_STAT_ITEMS);
  		user = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[2]);
  		nice = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[3]);
  		system = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[4]);
  		idle = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[5]);
  		iowait = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[6]);
  		irq = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[7]);
  		softirq = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[8]);
  	}

  	public long getCpuTotal() {
  		return user + nice + system + iowait + irq + softirq;
  	}

  	public long getTotal() {
  		return user + nice + system + idle + iowait + irq + softirq;
  	}
  }

  private static class MyCpuStatInfo {
  	private static final int MIN_CPU_STAT_ITEM_NUM = 17;
  	private static final String[] INVALID_RAW_CPU_STAT_ITEMS = new String[MIN_CPU_STAT_ITEM_NUM];

  	public final long utime;
  	public final long stime;
  	public final long cutime;
  	public final long cstime;
  	
  	public static MyCpuStatInfo get() {
  		BufferedReader cpuStatInfoReader = null;
  		try {
  			cpuStatInfoReader = new BufferedReader(new InputStreamReader(new FileInputStream(MY_STAT_ABS_DIR), UTF8_CHARSET));
  			return new MyCpuStatInfo(cpuStatInfoReader.readLine());
  		} catch (Exception e) {
  			GPMLogger.w(e, "get my cpu stat info failed");
  			return new MyCpuStatInfo(null);
  		} finally {
  			if (null != cpuStatInfoReader) {
  				try {
  					cpuStatInfoReader.close();
  				} catch (IOException ignored) {
  				}
  			}
  		}
  	}

  	private MyCpuStatInfo(String cpuStatLine) {
  		String[] rawCpuStatItems = CpuStatInfoHelper.buildRawCpuStatItems(cpuStatLine, MIN_CPU_STAT_ITEM_NUM, INVALID_RAW_CPU_STAT_ITEMS);
  		utime = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[13]);
  		stime = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[14]);
  		cutime = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[15]);
  		cstime = CpuStatInfoHelper.buildCpuStatItem(rawCpuStatItems[16]);
  	}

  	public long getCurrentThreadCpuTotal() {
  		return utime + stime;
  	}

  	public long getCpuTotal() {
  		return utime + stime + cutime + cstime;
  	}
  }

  • IOS采集代码：

      // ============当前进程cpu使用率============
  - (double) getCPU {
  	kern_return_t kr;
  	task_info_data_t tinfo;
  	mach_msg_type_number_t task_info_count;
  	task_info_count = TASK_INFO_MAX;
  	kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
  	if (kr != KERN_SUCCESS) {
  		GSDKLOG(@"================CPU:%.2f",-1.0f);
  		return -1;
  	}
  	task_basic_info_t      basic_info;
  	thread_array_t         thread_list;
  	mach_msg_type_number_t thread_count;
  	thread_info_data_t     thinfo;
  	mach_msg_type_number_t thread_info_count;
  	thread_basic_info_t basic_info_th;
  	uint32_t stat_thread = 0; // Mach threads
  	basic_info = (task_basic_info_t)tinfo;
  	// get threads in the task
  	kr = task_threads(mach_task_self(), &thread_list, &thread_count);
  	if (kr != KERN_SUCCESS) {
  		GSDKLOG(@"=============CPU:%.2f",-1.0f);
  		return -1;
  	}
  	if (thread_count > 0)
  		stat_thread += thread_count;
  	long tot_sec = 0;
  	long tot_usec = 0;
  	float tot_cpu = 0;
  	int j;
  	for (j = 0; j < thread_count; j++) {
  		thread_info_count = THREAD_INFO_MAX;
  		kr = thread_info(thread_list[j], THREAD_BASIC_INFO, (thread_info_t)thinfo, &thread_info_count);
  		if (kr != KERN_SUCCESS) {
  			GSDKLOG(@"=========CPU:%.2f",-1.0f);
  			return -1;
  		}
  		basic_info_th = (thread_basic_info_t)thinfo;
  		if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
  			tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
  			tot_usec = tot_usec + basic_info_th->system_time.microseconds + basic_info_th->system_time.microseconds;
  			tot_cpu = tot_cpu + basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
  		}
  	} // for each thread
  	kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
  	GSDKLOG(@"=============CPU:%.2f",tot_cpu);
  	return tot_cpu;
  }


  // ============当前进程cpu使用率============
  processor_info_array_t cpuInfo, prevCpuInfo;
  mach_msg_type_number_t numCpuInfo, numPrevCpuInfo;
  unsigned numCPUs;
  NSLock * CPUUsageLock;

  - (void) getSystemCPU {
  	int mib[2U] = { CTL_HW, HW_NCPU };
  	size_t sizeOfNumCPUs = sizeof(numCPUs);
  	int status = sysctl(mib, 2U, &numCPUs, &sizeOfNumCPUs, NULL, 0U);
  	if (status)
  		numCPUs = 1;
  	CPUUsageLock = [[NSLock alloc] init];
  }

  - (double) getSystemCPUCircle {
  	natural_t numCPUsU = 0U;
  	kern_return_t err = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numCPUsU, &cpuInfo, &numCpuInfo);
  	if (err == KERN_SUCCESS) {
  		[CPUUsageLock lock];
  		float tot_inUse = 0;
  		float tot_total = 0;
  		for(unsigned i = 0U; i < numCPUs; ++i) {
  			float inUse, total;
  			if(prevCpuInfo) {
  				inUse = ((cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER] - prevCpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER])
                   + (cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] - prevCpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM])
                   + (cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]   - prevCpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]));
  				total = inUse + (cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE] - prevCpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE]);
  			} else {
  				inUse = cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER] + cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] + cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE];
  				total = inUse + cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE];
  			}
  			tot_inUse += inUse;
  			tot_total += total;
  		}
  		[CPUUsageLock unlock];
  		if (prevCpuInfo) {
  			size_t prevCpuInfoSize = sizeof(integer_t) * numPrevCpuInfo;
  			vm_deallocate(mach_task_self(), (vm_address_t)prevCpuInfo, prevCpuInfoSize);
  		}
  
  		prevCpuInfo = cpuInfo;
  		numPrevCpuInfo = numCpuInfo;
  
  		cpuInfo = NULL;
  		numCpuInfo = 0U;
  		if (tot_total > 0) {
  			GSDKLOG(@"CPU Usage: %.2f%%",tot_inUse/tot_total * 100.f);
  			return tot_inUse/tot_total * 100.f;
  		} else {
  			return -1;
  		}
  	} else {
  		GSDKLOG(@"Error!");
  		return -1;
  	}
  }

2. memory

  • Android采集代码：

      public static long getAvailableMemory(Context context) {
  	if (null == context) {
  		return VALUE_GET_FAILED;
  	}
  	@SuppressWarnings("AlibabaLowerCamelCaseVariableNaming")
  	long availableMemoryInMB = VALUE_GET_FAILED;
  	try {
  		ActivityManager activityManager =
              (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  		if (null == activityManager) {
  			return availableMemoryInMB;
  		}
  		ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
  		activityManager.getMemoryInfo(memoryInfo);
  		availableMemoryInMB = memoryInfo.availMem / (1024 * 1024);
  	} catch (Exception e) {
  		GPMLogger.w(e, "availableMemoryInMB failed");
  	}
  	return availableMemoryInMB;
  }
  
  // ============当前设备可用内存大小（原方案）============
  public static long getProcessMemery() {
  	// TODO: 厂商反馈Debug.getPss()计算还是过于复杂，后续考虑使用Process.getPss()或者仿照Process.getPss()实现
  	// NOTE: 当前实现应该在低优先级后台线程调用
  	if (Build.VERSION_CODES.ICE_CREAM_SANDWICH <= Build.VERSION.SDK_INT) {
  		return Debug.getPss() / 1024;
  	}
  	// NOTE: 仅在Android14下使用，不涉及私有API访问限制
  	// Android 2.3上Process已有getPss方法
  	// https://android.googlesource.com/platform/frameworks/base/+/refs/heads/gingerbread/core/java/android/os/Process.java
  	try {
  		Method getPssMethod = Process.class.getMethod(GET_PSS_METHOD_NAME, int.class);
  		return ((long) getPssMethod.invoke(null, Process.myPid())) / 1024;
  	} catch (Exception e) {
  		return VALUE_GET_FAILED;
  	}
  }
  // ============当前设备可用内存大小（优化后方案）============
  private static ActivityManager sActivityMgr = null;
  private static int sPid = 0;

  public static int getProcessMemery(Context context) {
  	try {
  		if (sActivityMgr == null) {
  			sActivityMgr = (ActivityManager) context.getSystemService(context.ACTIVITY_SERVICE);
  		}

  		if (sPid == 0) {
  			sPid = android.os.Process.myPid();
  		}

  		if (sActivityMgr == null || sPid == 0) {
  			return -1;
  		}

  		int[] myMempid = new int[]{sPid};
  		Debug.MemoryInfo[] memoryInfo = sActivityMgr.getProcessMemoryInfo(myMempid);
  		int memSize = 0;
  		if (memoryInfo != null && memoryInfo.length > 0) {
  			memSize = memoryInfo[0].getTotalPss();
  		}
  		return memSize;
  	} catch (Exception e) {
  		Logger.e("PSS fetch error: " + e.getMessage());
  	}
  	return -1;
  }

  • IOS采集代码：

      // ============当前设备可用内存大小============
  - (double) getSystemAvailableMemory {
  	// 获取当前设备可用内存(单位：MB）
  	vm_statistics_data_t vmStats;
  	mach_msg_type_number_t infoCount = HOST_VM_INFO_COUNT;
  	kern_return_t kernReturn = host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&vmStats, &infoCount);
  	if (kernReturn != KERN_SUCCESS) {
  		GSDKLOG(@"AvailableMemory=====%.2f",-1.0f);
  		return -1;
  	}

  	double availMem = (vm_page_size * vmStats.free_count + vm_page_size * vmStats.inactive_count) / 1024.0 / 1024.0;
  	GSDKLOG(@"AvailableMemory=====%.2f",availMem);
  	return availMem;
  }

  // ============当前进程使用内存大小（原方案）============
  - (double) getFootPrint {
  	task_vm_info_data_t vmInfo;
  	mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
  	kern_return_t result = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
  	if (result != KERN_SUCCESS) {
  		GSDKLOG(@"FootPrint=====%.2f",-1.0f);
  		return -1;
  	}
  	GSDKLOG(@"FootPrint=====%i",(int)((vmInfo.phys_footprint) / 1024.0 / 1024.0));
  	return vmInfo.phys_footprint / 1024.0 / 1024.0;
  }

  // ============当前进程使用内存大小（优化后方案）============
  - (instancetype) init {
  	if (self = [super init]) {
  		_isLowLevelDevice = NO;
  		struct utsname systemInfo;
  		uname(&systemInfo);
  		NSString *platform = [NSString stringWithCString:systemInfo.machine encoding:NSASCIIStringEncoding];
  		if ([platform isEqualToString:@"iPhone7,1"] || [platform isEqualToString:@"iPhone7,2"] || [platform isEqualToString:@"iPhone6,1"] || [platform isEqualToString:@"iPhone6,2"]) {
  			_isLowLevelDevice = YES;
  		}
  	}
  	return self;
  }
  
  - (double) getFootPrint {
  	task_vm_info_data_t vmInfo;
  	mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
  	kern_return_t result = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
  	if (result != KERN_SUCCESS) {
  		GSDKLOG(@"FootPrint=====%.2f",-1.0f);
  		return -1;
  	}
  	double footPrint = -1;
  	if (_isLowLevelDevice || [UIDevice.currentDevice.systemVersion doubleValue] >= 12.0) {
  		footPrint = vmInfo.phys_footprint / 1024.0 / 1024.0;
  	}
  	if ([UIDevice.currentDevice.systemVersion doubleValue] < 12.0) {
  		footPrint = (vmInfo.internal + vmInfo.compressed - vmInfo.purgeable_volatile_pmap) / 1024.0 / 1024.0;
  	}
  	GSDKLOG(@"FootPrint=====%i",int((vmInfo.phys_footprint) / 1024.0 / 1024.0));
  	return footPrint;
  }

二、性能数据统一上报类示例

使用同一个TDMReportHelper实例进行上报即可：

TDMReportHelper eventReportHandler = new TDMReportHelper(eventName);
eventReportHandler.addSS(key, value);
eventReportHandler.report();
eventReportHandler.destory();
酷爽
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
神奇，一段JavaScript代码生成会动的足球 | 世界杯征文活动
神奇代码在哪里
12-07 3万+
花有重开日，人无再少年。疯狂无大小，热爱即疯狂！四年一次的世界杯正在卡塔尔进行着，响应`CSDN`号召，来一篇“水”文。使用`JavaScript`代码，在浏览器生成会动的足球。好了，以上就是一段JavaScript代码生成会动的足球的全部内容。通过练习和调试，学到了js网络图片转base64格式字符串、使用base64格式字符串创建img标签图片对象和使用JavaScript代码旋转div等前端知识，同时感受到了浏览器开发者模式的强大和便捷。
Linux安装gpm(实现Linux复制粘贴)
weixin_44532220的博客
11-03 5530
在linux里面安装gpm可实现复制粘贴。 >注：实现复制粘贴是在linux系统内部实现，不是指在主机和你的虚拟机之间，这个是不可能的。如果不安装gpm在虚拟机是没有办法复制粘贴的，在命令行里你就可以感受到。 以下是本人安装过程中的一系列步骤。 1. yum install -y gpm* 接着我们发现command ‘yum’ not found,是因为我没有安装gpm 所以还要安装以下...
GPMdl:GPM自动下载
05-22
GPMdl GPM自动下载
bjnm gpm 2017.zip
04-27
2017年 日分辨率
stm32F429的CPU外部设备例程（41个）.rar
09-07
stm32f429的例程，包含几乎全部外设，详细内容可以参照安富莱开发板的板上资源，一共有41个例程
2022-03-24 RK3566 MIPI屏 调试记录，panel-init-sequence 命令格式介绍
海月汐辰
03-24 8330
一、Single-channel mipi屏的硬件连接如下： 二、根据屏厂给的初始化代码配置dts了，屏厂给的初始化代码分几种形式，这个文章里面RK PX30_android8.1的mipi屏调试_要不要买菜！的博客-CSDN博客有比较详细的介绍。 三、RK dts里面panel-init-sequence 命令格式介绍。 四、我现在调试的屏幕厂家ST7701S_5.0BOE_IPS_2LINE初始化给的初始化如下： HSYNC:10 HBP:10 HADR:480...
GPM、FY-4A数据下载
weixin_43314180的博客
01-31 6780
一、GPM数据下载 打开NASA的官网GPM数据下载地址并登陆，若无账号则需要注册。点击data access 再点击左侧的GPM，也可直接点击data access下方的GPM。 在data range中选择你所需要的数据起始日期，然后点击spatial bounding box右侧的小地图logo，选择区域，最后search for data sets。 勾选subset后，选择subset ...
Golang并发编程-GPM协程调度模型原理及组成分析
程序员不鸣的博客
06-05 2404
Golang为了减少操作系统内核级线程上下文切换的开销以及提升调度效率，提出了GPM协程调度模型，GPM模型借助了用户级线程的实现思路，通过用户态的协程调度，能够在线程上实现多个协程的并发执行。 GPM三个字母分别表示的是Goroutine、Processor及Machine。 Goroutine代表着Golang中的协程，通过Goroutine封装的代码片段将以协程方式并发执行，是GPM调度器调度的基本单位。 Processor代表执行Goroutine的上下文环境及资源，是GPM调度器中关联内核级
linux安装gpm,Linux程序设计入门-gpm(转)
weixin_39830917的博客
05-26 254
#includevoidmain(intargc,char**argv){fd_setreadset;Gpm_Eventevent;Gpm_Connectconn;conn.eventMask=~0;conn.defaultMask=~GPM_HARD;conn.maxMod=0;conn.minMod=0;if(Gpm_Open(&conn,0)==-1){printf("Cannoto...
gpm-libs-1.20.7-6.el7.x86_64.rpm
11-01
linux 系统中的gpm rpm包，gpm-libs-1.20.7-6.el7.x86_64.rpm
GPM Contabilidad Edicion especial-开源
05-10
通用会计系统，特别为管理教堂，教堂，基督教中心等而编译。 主管密码为“ mpg”，对于其他类型的机构，请购买商业版
gpm-libs-1.20.7-5.el7.x86_64.rpm
11-29
离线安装包，亲测可用
tp-link r498GPM-ac v1.0官方系统升级固件 支持wiifi6 版本1.0.2
12-18
tp-link r498GPM-ac v1.0官方系统升级固件 支持wiifi6 版本1.0.2
gpm-spotify-export
02-13
gpm-spotify-export
教师平台html模块使用方法,GPM平台--指导教师操作指南
weixin_39847732的博客
06-10 315
GPM平台--指导教师操作指南一、登陆注意事项：1、在使用平台前，向学生讲明毕业综合实践全过程的目的、要求及流程安排。教师用户名：教师工号；教师初始密码：888888。3、登陆后选择身份为“指导教师”4、用“指导教师”身份登陆后可看到“基本信息”页面a)每周统计：显示当前指导老师的学生人数、已参加实习人数、未参加实习人数、已写周记人数、未写周记人数、已交流人数b)任务栏：显示所指导的学生提交的未处...
gpm 1.20.3-1 in Core
weixin_33739646的博客
05-03 50
gpm 1.20.3-1 in CoreWhen attempting to update to gpm 1.20.3-1, you will most likely get the following error message:error: could not prepare transactionerror: failed to commit transaction (...
Go-GPM模型浅析
qq_38557583的博客
03-29 272
Go语言-GPM内存模型浅析 相关知识基础 什么是多线程 多线程一般指的是操作系统级别的多线程。指的是任务的调度不由我们手动触发，而是通过一些程序命令，把任务交给系统来进行调度，而系统怎么去调度这些任务，我们并不关心。只需要告诉系统哪些任务是优先的，哪些是不怎么重要的，系统就会根据这种优先级去分配处理任务。 并发和并行 并发：宏观上面的同时执行，实际上是指任务在同一时段能够共同被调度的一种描述。 并行：同一时刻的执行，指任务能够在同一个时刻被调度同时执行。 具体在计算机中的体现呢？ 我们已经知道多线程
浅谈一种规避iOS多线程Crash的方案
iOS开发工具人
03-19 3377
一般来说，多线程编程因具有以下几个优点，一直被广泛应用： 资源利用率更好 程序设计在某些情况下更简单 程序响应更快 但是因为多线程而导致的crash问题，也是令程序员非常头疼的一个问题，因为线程调度执行顺序的不确定性，造成了crash一般都是小概率出现，在开发测试阶段很难发现，而一旦上线面对用户，造成的影响却是不容小觑的。 一、Crash的场景 有一种特别常见的会造成crash的场景为：多线程读写可变数组/字典 我们来看几个简单的测试代码，看看到底在什么情况下会引起Crash： // 1.
StandardEngine[Tomcat].StandardHost[localhost].TomcatEmbeddedContext[/gpm-gpms-major] failed to start
最新发布
10-10
这个错误通常表示Tomcat无法启动指定的应用程序上下文。可能有多种原因导致此错误，例如配置问题、依赖项问题或文件系统权限问题。您可以尝试以下解决方案： 1. 检查应用程序上下文的配置文件是否正确。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值