Linux/Android Disk 测试

最新推荐文章于 2024-05-22 10:06:43 发布
最新推荐文章于 2024-05-22 10:06:43 发布
阅读量421 收藏 1
点赞数
分类专栏： Android驱动开发 文章标签： Disk压力测试 Linux Disk测试 Android Disk测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaochaoyun/article/details/107177927
版权

 1.  可以作为FLASH/DISK压力测试工具

      1.1 Linux编译：gcc test.c -o test

      1.2 Android编译：

include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -O2 -Wall 
LOCAL_SHARED_LIBRARIES := libutils libcutils libc
LOCAL_C_INCLUDES += 头文件路劲/include 
LOCAL_SRC_FILES := test.c
LOCAL_MODULE := test

include $(BUILD_EXECUTABLE)

测试代码： 

#ifndef _GNU_SOURCE
#define _GNU_SOURCE	/* for O_DIRECT */
#endif

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <sched.h>
#include <sys/resource.h>
#include <linux/sched.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/vfs.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/times.h>
#include <time.h>

#define	DISK_SIGNATURE		0xD150D150

#define	KBYTE			(1024)
#define	MBYTE			(1024 * KBYTE)
#define	KB(v)			(v * KBYTE)
#define	MB(v)			(KB(v) * KBYTE)

#define	BUFFER_DEF_SIZE		MB(1)
#define	BUFFER_MIN_SIZE		(4)
#define	BUFFER_MAX_SIZE		MB(50)
#define	FILE_DEF_SIZE		BUFFER_MAX_SIZE
#define	FILE_MIN_SIZE		MB(1)
#define	FILE_MAX_SIZE		MB(100)
#define	SPARE_SIZE		MB(5)

#define	FILE_PREFIX		"test"
#define	DISK_PATH		"./"
#define	DISK_COUNT		(1)
#define SECTOR_SIZE		KB(1)

#define	FILE_O_SYNC		(1<<0)
#define	FILE_O_DIRECT		(1<<1)

#define	FILE_W_FLAG		(O_RDWR | O_CREAT)
#define	FILE_R_FLAG		(O_RDONLY)

#define	SE(_us)			(_us/1000000)
#define	US(_us)			(_us%1000000)

#define MBS(_l, _u)		((((u64)_l/(u64)_u)*1000000)/(u64)MBYTE)
#define	MBU(_l, _u)		((((u64)_l/(u64)_u)*1000000)%(u64)MBYTE)

#define	RUN_TIME_US(s) { \
	struct timeval tv; \
	u64 t; \
	gettimeofday(&tv, NULL); \
	t = (tv.tv_sec*1000000) + (tv.tv_usec),	s = t; \
	while (s == t) { \
		gettimeofday(&tv, NULL); \
		t = (tv.tv_sec*1000000) + (tv.tv_usec);	\
	} \
	s = t; \
	}

#define	END_TIME_US(s, e) { \
	struct timeval tv; \
	gettimeofday(&tv, NULL); \
	e = (tv.tv_sec*1000000) + (tv.tv_usec);	\
	e = e - s; \
	}

#define RAND_SIZE(min, max, aln, val) { \
	val = rand() % max; \
	val = ((val+aln-1)/aln)*aln; \
	if (min > val) \
		val = min; \
	}

typedef unsigned long long  u64;

static int sched_set_new(pid_t pid, int policy, int priority)
{
	struct sched_param param;
	int maxpri = 0, minpri = 0;
	int ret;

	switch (policy) {
	case SCHED_NORMAL:
	case SCHED_FIFO:
	case SCHED_RR:
	case SCHED_BATCH:
		break;
	default:
		fprintf(stderr, "invalid policy %d (0~3)\n", policy);
		return -EINVAL;
	}

	if (policy == SCHED_NORMAL) {
		/*
		 * #define NICE_TO_PRIO(nice)
		 *(MAX_RT_PRIO + (nice) + 20), MAX_RT_PRIO 100
		 */
		maxpri =  20;
		minpri = -20; /* nice */
	} else {
		maxpri = sched_get_priority_max(policy);
		minpri = sched_get_priority_min(policy);
	}

	if ((priority > maxpri) || (minpri > priority)) {
		fprintf(stderr,
			"\nFail, invalid priority (%d ~ %d)...\n",
			minpri, maxpri);
		return -EINVAL;
	}

	if (policy == SCHED_NORMAL) {
		param.sched_priority = 0;
		ret = sched_setscheduler(pid, policy, &param);
		if (ret) {
			fprintf(stderr,
				"Fail, sched_setscheduler (%d)\n\n", ret);
			return ret;
		}
		ret = setpriority(PRIO_PROCESS, pid, priority);
		if (ret)
			fprintf(stderr, "Fail, setpriority (%d)\n\n", ret);
	} else {
		param.sched_priority = priority;
		ret = sched_setscheduler(pid, policy, &param);
		if (ret)
			fprintf(stderr,
				"Fail, sched_setscheduler (%d)\n\n", ret);
	}

	return ret;
}

static long long disk_disk_avail(const char *disk, long long *ptot,
				 int debug)
{
	long long total, used, free, avail;
	double used_percent;
	struct statfs64 fs;
	struct stat st;

	if (stat(disk, &st)) {
		if (mkdir(disk, 0755)) {
			fprintf(stderr,
				"Fail, make dir path:%s (%d)\n", disk, errno);
			return 0;
		}
	} else {
		if (!S_ISDIR(st.st_mode)) {
			fprintf(stderr,
				"Fail, file exist %s (%d)!!!\n", disk, errno);
			return 0;
		}
	}

	if (statfs64(disk, &fs) < 0) {
		fprintf(stderr,
			"Fail, status fs %s (%d)\n", disk, errno);
		return 0;
	}

	total = (fs.f_bsize * fs.f_blocks);
	free = (fs.f_bsize * fs.f_bavail);
	avail = (fs.f_bsize * fs.f_bavail);
	used = (total - free);
	used_percent = ((double)used/(double)total)*100;

	if (debug) {
		printf("--------------------------------------\n");
		printf("PATH       : %s\n", disk);
		printf("Total size : %16lld\n", total);
		printf("Free  size : %16lld\n", free);
		printf("Avail size : %16lld\n", avail);
		printf("Used  size : %16lld\n", used);
		printf("Block size : %8d B\n", (int)fs.f_bsize);
		printf("Use percent: %16f %%\n", used_percent);
		printf("--------------------------------------\n");
	}

	if (ptot)
		*ptot = total;

	return avail;
}

static int disk_obtain_space(const char *disk, int search, long long request)
{
	char file[256];
	long long avail;
	int  i = 0;

	while (1) {
		/* exist file */
		sprintf(file, "%s/%s.%d.txt", disk, FILE_PREFIX, i);

		if (access(file, F_OK) < 0) {
			if (i > search) {
				fprintf(stderr,
					"Fail, access %s (%d)\n", file, errno);
				return -EINVAL;
			}
			i++; /* next file */
			continue;
		}

		/* remove to obtain free */
		if (remove(file) < 0) {
			fprintf(stderr,
				"Fail, remove %s (%d)\n", file, errno);
			return -EINVAL;
		}
		sync();

		/* check free */
		avail = disk_disk_avail(disk, NULL, 0);
		if (avail > request)
			break;
		i++; /* next file */
	}

	return 0;
}

static int file_read_sign(const char *file,
			  long long *pf_length, int *pb_length)
{
	unsigned int data[4] = { 0, };
	long long f_size;
	int fd, b_size;
	int ret;

	fd = open(file, O_RDWR|O_SYNC, 0777);
	if (fd < 0) {
		fd = open(file, O_RDWR, 0777);
		if (fd < 0)
			return -EINVAL;
	}

	ret = read(fd, (void *)data, sizeof(data));
	close(fd);

	if (ret < (int)sizeof(data))
		return -EINVAL;

	if (data[0] != DISK_SIGNATURE) {
		fprintf(stderr,
			"Fail, Unknown signature 0x%08x (0x%08x)\n",
			data[0], DISK_SIGNATURE);
		return -EINVAL;
	}

	b_size = data[1];
	f_size = (long long)data[2];

	if (pf_length)
		*pf_length = f_size;

	if (pb_length)
		*pb_length = b_size;

	return 0;
}

static int file_write_sign(const char *file, long long f_length, int b_length)
{
	unsigned int data[4];
	int fd, ret;

	fd = open(file, O_RDWR|O_SYNC, 0777);
	if (fd < 0) {
		fprintf(stderr, "Fail, info open %s (%d)\n", file, errno);
		return -EINVAL;
	}

	data[0] = DISK_SIGNATURE;
	data[1] = b_length;
	data[2] = (f_length) & 0xFFFFFFFF;
	data[3] = (f_length >> 32) & 0xFFFFFFFF;

	ret = write(fd, (void *)&data, sizeof(data));
	close(fd);

	if (ret < (int)sizeof(data))
		return -EINVAL;

	sync();

	return 0;
}

static long long file_write(const char *file, unsigned long f_flags,
			    long long f_length, int b_length, u64 *time,
			    int wo, int verify)
{
	int fd, flags = O_RDWR | O_CREAT;
	long long w_len, r_len;
	int *buf;
	u64 ts = 0, te;
	int count, i, ret;

	if (b_length > BUFFER_MAX_SIZE)
		b_length = BUFFER_MAX_SIZE;

	if (b_length > f_length)
		b_length = f_length;

	ret = posix_memalign((void *)&buf, SECTOR_SIZE, b_length);
	if (ret) {
		fprintf(stderr,
			"Fail: allocate memory buffer %d (%d)\n",
			b_length, ret);
		return -ENOMEM;
	}

	/* fill buffer */
	for (i = 0; i < b_length/4; i++)
		buf[i] = i;

	/* wait for "start of" clock tick */
	if (f_flags & FILE_O_SYNC)
		sync();

	flags = FILE_W_FLAG | (f_flags & FILE_O_DIRECT ? O_DIRECT : 0);

	fd = open(file, flags, 0777);
	if (fd < 0) {
		flags = FILE_W_FLAG | (f_flags & FILE_O_SYNC ? O_SYNC : 0);

		fd = open(file, flags, 0777);
		if (fd < 0) {
			flags = FILE_W_FLAG;

			fd = open(file, flags, 0777);
			if (fd < 0) {
				fprintf(stderr,
					"Fail, write open %s (%d)\n",
					file, errno);
				free(buf);
				return -EINVAL;
			}
		}
	}

	count = b_length, w_len = 0;

	if (time)
		RUN_TIME_US(ts);

	while (count > 0) {
		ret = write(fd, buf, count);
		if (ret < 0) {
			fprintf(stderr,
				"Fail, wrote %lld (%d)\n", w_len, errno);
			break;
		}

		w_len += ret;
		count = f_length - w_len;

		if (count > b_length)
			count = b_length;
	}

	/* End */
	if (f_flags & FILE_O_SYNC)
		sync();

	if (time) {
		END_TIME_US(ts, te);
		*time = te;
	}

	close(fd);

	if (w_len != f_length) {
		free(buf);
		return -EINVAL;
	}

	/* set test file info */
	if (file_write_sign(file, f_length, b_length) < 0)
		return -EINVAL;

	if (wo)
		return f_length;

	/* verify open */
	flags = O_RDONLY | (flags & ~(FILE_W_FLAG));

	fd = open(file, flags, 0777);
	if (fd < 0) {
		fprintf(stderr,
			"Fail, write verify open %s (%d)\n", file, errno);
		free(buf);
		return -EINVAL;
	}

	count = b_length, r_len = 0;

	while (count > 0) {
		ret = read(fd, buf, count);
		if (ret < 0) {
			fprintf(stderr,
				"Fail, verified %lld (%d)\n", r_len, errno);
			break;
		}

		if (verify) {
			for (i = (r_len ? 0 : 4); b_length/4 > i; i++) {
				if (buf[i] != i) {
					fprintf(stderr,
						"Fail, verified 0x%llx, not equal 0x%08x/0x%08x\n",
						(r_len + (i*4)),
						(unsigned int)buf[i], i);
					goto err_write;
				}
			}
		}

		r_len += ret;
		count = f_length - r_len;

		if (b_length < count)
			count = b_length;
	}

err_write:
	close(fd);
	free(buf);

	if (r_len != f_length)
		return -EINVAL;

	return r_len;
}

static long long file_read(const char *file, unsigned long f_flags,
			   long long f_length, int b_length, u64 *time,
			   int verify)
{
	int fd, flags = O_RDONLY;
	unsigned int *buf;
	long long r_len, f_len = 0;
	u64 ts = 0, te;
	int count, b_len = 0, d_len;
	long ret;
	int num;

	if (file_read_sign(file, &f_len, &b_len) < 0)
		return -EINVAL;

	if (f_length > f_len)
		f_length = f_len;

	if (b_length > BUFFER_MAX_SIZE)
		b_length = BUFFER_MAX_SIZE;

	if (b_length > f_length)
		b_length = f_length;

	/* disk cache flush */
	if (!access("/proc/sys/vm/drop_caches", W_OK)) {
		if (f_flags & FILE_O_SYNC)
			ret = system("echo 3 > /proc/sys/vm/drop_caches > /dev/null");
	}

	ret = posix_memalign((void *)&buf, SECTOR_SIZE, b_length);
	if (ret) {
		fprintf(stderr,
			"Fail: allocate memory %d (%d)\n", b_length, errno);
		return -ENOMEM;
	}

	memset(buf, 0, b_length);

	/* wait for "start of" clock tick */
	if (f_flags & FILE_O_SYNC)
		sync();

	/* verify open */
	flags = FILE_R_FLAG | (f_flags & FILE_O_DIRECT ? O_DIRECT : 0);

	fd = open(file, flags, 0777);
	if (fd < 0) {
		flags = FILE_R_FLAG | (f_flags & FILE_O_SYNC ? O_SYNC : 0);

		fd = open(file, flags, 0777);
		if (fd < 0) {
			flags = FILE_R_FLAG;
			fd = open(file, flags, 0777);
			if (fd < 0) {
				fprintf(stderr,
					"Fail, read open %s (%d)\n",
					file, errno);
				free(buf);
				return -EINVAL;
			}
		}
	}

	/* read and verify */
	count = b_length, r_len = 0, num = 0, b_len /= 4, d_len = b_len - 4;

	if (time)
		RUN_TIME_US(ts);

	while (count > 0) {
		ret = read(fd, buf, count);
		if (ret < 0) {
			fprintf(stderr,
				"Fail, read %lld (%d)\n", r_len, errno);
			break;
		}

		/* verify */
		if (verify) {
			for (num = (r_len ? 0 : 4); count/4 > num; num++) {
				if (!d_len)
					d_len = b_len;

				if (buf[num] != (unsigned int)(b_len - d_len)) {
					fprintf(stderr,
						"Fail, read 0x%llx, not equal 0x%08x vs 0x%08x ---\n",
						(r_len + (num * 4)),
						(unsigned int)buf[num],
						(unsigned int)(b_len - d_len));
					goto err_read;
				}
				d_len--;
			}
		}

		r_len += ret;
		count = f_length - r_len;

		if (b_length < count)
			count = b_length;
	}

	/* End */
	if (f_flags & FILE_O_SYNC)
		sync();

	if (time) {
		END_TIME_US(ts, te);
		*time = te;
	}

err_read:
	close(fd);
	free(buf);

	if (r_len != f_length)
		return -EINVAL;

	return r_len;
}

static long long parse_length(int argc, char **argv, char *str,
			      long long *min, long long *max,
			      const char *smin, const char *smax,
			      bool *random)
{
	char *s;
	long long MIN = min ? *min : 0;
	long long MAX = max ? *max : 0;
	long long length = 0;
	bool find = false;
	int i;

	if (!str)
		return 0;

	if (strchr(str, 'k') || strchr(str, 'K')) {
		length = KB(strtoll(str, NULL, 10));
	} else if (strchr(str, 'm') || strchr(str, 'M')) {
		length = MB(strtoll(str, NULL, 10));
	} else if ((s = strchr(str, 'r'))) {
		for (i = 0; i < argc; i++) {
			if (s == argv[i])
				find = true;

			if (!find)
				continue;

			s = smin ? strstr(argv[i], smin) : NULL;
			if (s && min) {
				s = s + strlen(smin);
				if (strchr(s, 'k') || strchr(s, 'K'))
					*min = KB(strtoll(s, NULL, 10));
				else if (strchr(s, 'm') || strchr(s, 'M'))
					*min = MB(strtoll(s, NULL, 10));
				else
					*min = strtoll(s, NULL, 10);
			}

			s = smax ? strstr(argv[i], smax) : NULL;
			if (s && max) {
				s = s + strlen(smax);
				if (strchr(s, 'k') || strchr(s, 'K'))
					*max = KB(strtoll(s, NULL, 10));
				else if (strchr(s, 'm') || strchr(s, 'M'))
					*max = MB(strtoll(s, NULL, 10));
				else
					*max = strtoll(s, NULL, 10);
			}
		}

		if (random)
			*random = true;

		if (min && MIN > *min)
			*min = MIN;

		if (min && MAX < *min)
			*min = MAX;

		if (max && MIN > *max)
			*max = MIN;

		if (max && MAX < *max)
			*max = MAX;
	} else {
		/* align with sector size */
		length = (strtoll(str, NULL, 10) + SECTOR_SIZE - 1) /
			  SECTOR_SIZE * SECTOR_SIZE;
	}

	return length;
}

static int test_write(const char *disk, const char *file,
		      ulong f_flags, long long f_length, int b_length,
		      long long *length, int counts, bool verify, u64 *time)
{
	long long disk_avail;
	long long size;

	/*
	 * check disk free
	 */
	disk_avail = disk_disk_avail(disk, NULL, 0);
	if (f_length > disk_avail) {
		int ret = disk_obtain_space(disk, counts, f_length);

		if (ret < 0) {
			fprintf(stderr,
				"No space left, free %lld, req %lld\n",
				disk_disk_avail(disk, NULL, 0), f_length);
			return -ENOMEM;
		}
	}

	size = file_write(file, f_flags, f_length, b_length,
			    time, 1, verify);
	if (size < 0) {
		fprintf(stderr, "Fail write file, length %lld\n", size);
		return (int)size;
	}

	if (length)
		*length = size;

	return 0;
}

static int test_read(const char *disk, const char *file,
		     ulong f_flags, long long f_length, int b_length,
		     long long *length, int counts, bool verify, u64 *time)
{
	long long size;

	/*
	 * check exist file
	 */
	if (file_read_sign(file, NULL, NULL) < 0) {
		long long disk_avail = disk_disk_avail(disk, NULL, 0);

		if (disk_avail < f_length) {
			int ret = disk_obtain_space(disk, counts, f_length);

			if (ret < 0) {
				fprintf(stderr,
					"No space left, free %lld, req %lld\n",
					disk_disk_avail(disk, NULL, 0),
					f_length);
				return ret;
			}
		}

		size = file_write(file, f_flags, f_length, b_length,
				    NULL, 0, verify);
		if (size < 0) {
			fprintf(stderr,
				"Fail write file to read, length %lld\n", size);
			return (int)size;
		}
	}

	/*
	 * read test
	 */
	size = file_read(file, f_flags, f_length, b_length, time, verify);
	if (size < 0) {
		fprintf(stderr, "Fail read length %lld\n", size);
		return (int)size;
	}

	if (length)
		*length = size;

	return 0;
}

static void print_usage(void)
{
	printf("\n");
	printf("usage: options\n");
	printf("-p directory path, default current path\n");
	printf("-r read  option, default read\n");
	printf("-w write option, default read\n");
	printf("-b rw buffer len, default %dKbyte (k=Kbyte, m=Mbyte, r=random)\n",
		BUFFER_DEF_SIZE/MBYTE);
	printf("   bmin=n, random min, default and limit min  %dbyte\n",
		BUFFER_MIN_SIZE);
	printf("   bmax=n, random max, default and limit max %dMbyte\n",
		BUFFER_MAX_SIZE/MBYTE);
	printf("-f rw file len, default %dMbyte (k=Kbyte, m=Mbyte, r=random)\n",
		FILE_DEF_SIZE/MBYTE);
	printf("   fmin=n, random min, default and limit min %dMbyte\n",
		FILE_MIN_SIZE/MBYTE);
	printf("   fmax=n, random max, default and limit max %dMbyte\n",
		FILE_MAX_SIZE/MBYTE);
	printf("-c test count, default %d\n", DISK_COUNT);
	printf("-l loop\n");
	printf("-s no sync access, default sync\n");
	printf("-t no time info,\n");
	printf("-n set priority, FIFO 99\n");
	printf("-v skip verify\n");
	printf("\n");
}

/* program options */
struct option_t {
	const char *disk;
	char *buff_size, *file_size;
	int counts;
	long loop;
	bool rd, wr;
	bool fsync, rt_sched;
	bool verify, timei;
} option = {
	.disk = DISK_PATH,
	.counts = DISK_COUNT,
	.rd = false,
	.wr = false,
	.loop = 0,
	.fsync = true,
	.rt_sched = false,
	.verify = true,
	.timei = true,
};

static void parse_options(int argc, char **argv, struct option_t *op)
{
	int opt;

	while (-1 != (opt = getopt(argc, argv, "hrwp:b:f:c:l:stnv"))) {
		switch (opt) {
		case 'h':
			print_usage(); exit(1);
			break;
		case 'p':
			op->disk = optarg;
			break;
		case 'r':
			op->rd = true;
			break;
		case 'w':
			op->wr = true;
			break;
		case 'b':
			op->buff_size = optarg;
			break;
		case 'f':
			op->file_size = optarg;
			break;
		case 'c':
			op->counts = atoi(optarg);
			break;
		case 'l':
			op->loop = atoi(optarg);
			break;
		case 's':
			op->fsync = false;
			break;
		case 't':
			op->timei = false;
			break;
		case 'n':
			op->rt_sched = true;
			break;
		case 'v':
			op->verify = false;
			break;
		default:
			print_usage(), exit(1);
			break;
		}
	}
}

int main(int argc, char **argv)
{
	char file[256];
	struct option_t *op = &option;
	long long f_min = FILE_MIN_SIZE, f_max = FILE_MAX_SIZE;
	long long f_len = FILE_DEF_SIZE;
	long long b_min = BUFFER_MIN_SIZE, b_max = BUFFER_MAX_SIZE;
	long long b_len = BUFFER_DEF_SIZE;

	ulong f_flags = FILE_O_SYNC | FILE_O_DIRECT;
	bool rand_file_size = false, rand_buff_size = false;
	long long disk_avail;
	struct tm *tm;
	time_t tt;
	int i, count = 0;
	int ret;

	parse_options(argc, argv, op);

	/* get buffer length */
	b_len = parse_length(argc, argv, op->buff_size,
			     &b_min, &b_max, "bmin=", "bmax=", &rand_buff_size);

	if (!rand_buff_size && b_len > BUFFER_MAX_SIZE) {
		fprintf(stderr,
			"Fail, Invalid buffer %lld, max %d byte\n",
			b_len, BUFFER_MAX_SIZE);
		print_usage();
		exit(1);
	}

	if (!b_len)
		b_len = BUFFER_DEF_SIZE;

	f_len = parse_length(argc, argv, op->file_size,
			     &f_min, &f_max, "fmin=", "fmax=", &rand_file_size);

	if (!f_len)
		f_len = FILE_DEF_SIZE;

	if (!op->rd && !op->wr)
		op->rd = true;

	if (!op->fsync)
		f_flags = 0;

	srand(time(NULL));

	disk_avail = disk_disk_avail(op->disk, NULL, 0);

	time(&tt);
	tm = localtime(&tt);

	if (!realpath(op->disk, file)) {
		fprintf(stderr, "Invalid ditectory path for %s\n", op->disk);
		return 1;
	}

	printf("===============================================================\n");
	printf("Disk   : '%s'\n", file);
	printf("Test   : Read [%s], Write [%s]\n",
		op->rd ? "Yes" : "No", op->wr ? "Yes" : "No");

	if (rand_file_size)
		printf("File   : random, min %lld byte, max %lld byte (free %lld Mbyte)\n",
			f_min, f_max, disk_avail/MBYTE);
	else
		printf("File   : %lld byte (free %lld MByte)\n", f_len, disk_avail/MBYTE);

	if (rand_buff_size)
		printf("Buffer : random, min %lld byte, max %lld byte\n", b_min, b_max);
	else
		printf("Buffer : %lld byte\n", b_len);

	printf("Sync   : %s\n", op->fsync ? "Yes" : "No");
	printf("Time   : %s\n", op->timei ? "Yes" : "No");
	printf("Count  : %d\n", op->counts);
	printf("Loop   : %d\n", op->loop);
	printf("Start  : %d-%d-%d %d:%d:%d\n",
		tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
		tm->tm_hour, tm->tm_min, tm->tm_sec);
	printf("===============================================================\n");

	/* realtime schedule */
	if (op->rt_sched)
		sched_set_new(getpid(), SCHED_FIFO, 99);

	do {
		for (i = 0; i < op->counts; i++) {
			long long length = 0;
			u64 time = 0, *ptime = op->timei ? &time : NULL;

			if (rand_buff_size)
				RAND_SIZE(b_min, b_max, SECTOR_SIZE, b_len);

			if (rand_file_size)
				RAND_SIZE(f_min, f_max, f_min, f_len);

			sprintf(file, "%s/%s.%d.txt", op->disk, FILE_PREFIX, i);
			printf("I : %s, count [%3d/%3d]\n", basename(file), i, count);

			if (op->wr) {
				ret = test_write(op->disk, file, f_flags,
						f_len, b_len, &length,
						op->counts, op->verify, ptime);
				if (ret < 0)
					return ret;

				printf("W : %3lld.%06lld, %lld/%lld (%3lld.%6lld M/S)\n",
					time ? SE(time) : 0, time ? US(time) : 0, f_len, b_len,
					time ? MBS(length, time) : 0, time ? MBU(length, time) : 0);
			}

			if (op->rd) {
				ret = test_read(op->disk, file, f_flags,
						f_len, b_len, &length,
						op->counts, op->verify, ptime);
				if (ret < 0)
					return ret;
				printf("R : %3lld.%06lld, %lld/%lld (%3lld.%6lld M/S)\n",
					time ? SE(time) : 0, time ? US(time) : 0, f_len, b_len,
					time ? MBS(length, time) : 0, time ? MBU(length, time) : 0);
			}
			printf("\n");
		}
		count++;
	} while (count < op->loop);

	return 0;
}

 

村里小码农
关注
专栏目录
【QNX+Android虚拟化方案】37 - Android Kernel 各 IOSCHED 内核 IO 调度算法性能测试评估（MQ_DEADLINE、KYBER、BFQ）
|~~~热爱生活、努力学习的小伙汁~~~|
08-20 636
【QNX+Android虚拟化方案】37 - Android Kernel 各 IOSCHED 内核 IO 调度算法性能测试评估（MQ_DEADLINE、KYBER、BFQ）
Linux Lab Disk 使用记录
饕餮人的博客
03-01 523
Dell Mnnnn UEFI Only 启动项会出现三个 U 盘的启动项 第一次启动接 U 盘启动是两个启动项，进入后 运行 Ubuntu 启动项，后 reboot 第二次启动 U 盘启动项变成三个。 博通网卡没有网卡驱动 安装博通的网卡驱动 sudo apt install bcmwl-kernel-source 安装后能检测到网卡驱动，还能链接无线网络。 重启后，无线网卡无法识别。 触摸板驱动不是很好用 可以试试 xf86-input-synaptics 包 注：我在 ArchLinux 下使用的是
CrossPlatformDiskTest：Windows，macOS和Android存储（HDD，SSD，RAM）速度测试性能基准测试应用程序
02-06
跨平台磁盘测试（CPDT） 在Windows，macOS和Android设备上测量存储性能（SSD，HDD，USB闪存等）和RAM速度。 随机和顺序吞吐量（读/写操作）以MB / s计算，可以在移动平台和台式机平台与设备之间以一致且可靠的方式进行比较。 下载并尝试 Windows（x86和x64）和.NET Framework 4.8 macOS 10.13以上 Android 4.4以上 Play市场： ： APK： ： Linux控制台应用程序 GitHub回购： : 基准图 这个怎么运作 该测试将测量读取/写入每个块所需的时间（RAM->磁盘，Disk-> RAM，R
linux磁盘性能测试
热门推荐
xuyaqun的专栏
03-05 1万+
 120-test:/# apt-get install hdparm真实机器120上测试结果：测试磁盘性能（不cache）120-test:/home/lai# hdparm -t /dev/sda/dev/sda: Timing buffered disk reads:  346 MB in  3.02 seconds = 114.65 MB/sec测试磁盘性能（带cach
Android使用磁盘缓存DiskLruCache
小马快跑的博客
07-17 1037
DiskLruCache 不同于LruCache，LruCache是将数据缓存到内存中去，而DiskLruCache是外部缓存，例如可以将网络下载的图片永久的缓存到手机外部存储中去，并可以将缓存数据取出来使用，DiskLruCache不是google官方所写，但是得到了官方推荐，DiskLruCache没有编写到SDK中去，如需使用可直接copy这个类到项目中去。DiskLruCache地址： h
推荐一款跨平台磁盘性能测试利器——Cross Platform Disk Test（CPDT）
最新发布
gitblog_00096的博客
05-22 608
推荐一款跨平台磁盘性能测试利器——Cross Platform Disk Test（CPDT） 去发现同类优质开源项目:https://gitcode.com/ 1、项目介绍 在数字时代，我们依赖各种设备存储数据，而了解这些存储设备的性能变得至关重要。Cross Platform Disk Test (CPDT) 是一款强大的开源工具，它允许你在Windows、macOS和Android设备上测量...
Linux磁盘或者其他类型服务器压力测试的几款工具简介
数据库
01-04 204
㈠ dd：从一个源读取数据然后以比特形式写到另一个目标地址 [root@linwaterbin ~]# dd if=/dev/zero of=/home/oracle/disktest bs=1M count=512 conv=fdatasync 注释 if：从哪来 of：往哪去 bs：每次读取的数据块大小 count：读多少个bs conv：消除Linux内存缓存的影响，保证数据直接写入磁盘...
移动设备渗透测试秘籍：用Kali Linux测试Android与iOS
[移动设备渗透测试秘籍：用Kali Linux测试Android与iOS](https://www.42gears.com/wp-content/uploads/2023/02/Android-Encryption.png) # 1. 移动设备安全与渗透测试概述 移动设备安全与渗透测试是当今IT领域的...
android性能测试 app CPU占有率
m0_47884154的博客
09-14 1840
1.什么是proc? proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间，它以文件的形式为内核与进程提供通信的接口；用户和应用程序可以通过proc得到系统信息，并可以改变内核的某些参数，由于系统的信息，如进程是动态改变的，所以用户或应用程序读取/proc目录中的文件时，proc系统文件是动态从系统内核读出所需要的信息并提交的，从proc文件中可以获取系统、进cpu时间片情况，所以2次采集时间片的数据就可以获取进程CPU占用率； 进程CPU占用率=(processJiffiesTime2
【Android安全测试框架】：使用Kali Linux的案例分析与实践技巧
![【Android安全测试框架】：使用Kali Linux的案例分析与实践技巧]...# 1. Android安全测试框架概述 ## Android安全测试框架的重要性 Android作为全球市场份额最高的移动操作系统，其安全性一直是业界关注的焦点。...
Android disk缓存池,Android本地缓存DiskLruCache完整详细学习示例
weixin_35390057的博客
06-02 480
package cc.vv;import java.io.File;import java.io.InputStream;import java.io.OutputStream;import libcore.io.DiskLruCache;import libcore.io.Utils;import android.os.Bundle;import android.os.Handler;impor...
超级实用的Android磁盘缓存工具DiskDataCacher用法以及原理
Windy的专栏
12-21 2324
DiskDataCacher磁盘缓存工具用法以及原理原创文档，转载请注明出处 by WindyDiskDataCacher是一个轻量级的Android磁盘缓存工具，基于LRU算法实现，同时可以设置缓存有效期，使用起来十分方便。 源码：DiskDataCacher工具用途 用于缓存网络请求返回的数据，并且可以设置缓存数据的有效期，比如，缓存时间假设为1个小时，超时1小时后再次获取缓存会自动失效，让
disk性能测试
消磨时间的博客
05-11 1122
fio -ioengine=libaio -bs=32k -direct=1 -thread -rw=randread -size=10G -filename=fio_randread_test.txt -name=’MyTest’ -iodepth=4 -runtime=60 fio -ioengine=libaio -bs=32k -direct=1 -thread -rw=randwri...
采用dd工具做nandflash磨损均衡
chenliang0224的专栏
10-18 1010
最近在linux嵌入式平台上做nandflash的压力测试，即磨损均衡，通过dd工具生成一个大文件，然后测试程序去读取该文件的内容进行判断是否出现ECC校验错误，在测试程序内部出现了一个bug，测试程序每次使用dd 生成文件9次之后就会出现异常退出，具体log如下： [root@szclou /mnt/app]#./flash_stress read last total_cnt=47 **...
Android DiskLruCache完全解析，硬盘缓存的最佳方案
QG
08-31 1755
Android DiskLruCache完全解析，硬盘缓存的最佳方案
diskspd磁盘测试软件的使用
百里杨的博客
11-15 4427
一、简介 Diskspd 是一个微软开源的磁盘性能基准测试工具，其基于命令行界面，有非常多的测试参数可用，很强大。 名称 内容 开发语言 C++ 界面框架 无（在cmd中执行命令） 代码量 1万行 支持系统 Windows 官网地址 https://github.com/Microsoft/diskspd/wiki github地址 https://github.com/microsoft/diskspd 软件下载地址 https://github.com/Micro
Android存储系统之架构篇
hery186的专栏
07-25 5074
http://gityuan.com/2016/07/23/android-io-arch/ 基于Android 6.0的源码，剖析存储架构的设计 一、概述 本文讲述Android存储系统的架构与设计，涉及到最为核心的便是MountService和Vold这两个模块以及之间的交互。上一篇文章Android存储系统之源码篇从源码角度介绍相关模块的创建与启动过程，
Android DiskLruCache磁盘缓存
qq_39431405的博客
11-22 569
一 概述 记得在很早之前，我有写过一篇文章Android高效加载大图、多图解决方案，有效避免程序OOM，这篇文章是翻译自Android Doc的，其中防止多图OOM的核心解决思路就是使用LruCache技术。但LruCache只是管理了内存中图片的存储与释放，如果图片从内存中被移除的话，那么又需要从网络上重新加载一次图片，这显然非常耗时。对此，Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。只可惜，Android Doc中并没有对DiskLru
android磁盘缓存DiskLruCache使用
乐活青年的博客
08-29 443
private static final long DISK_CACHE_SIZE = 50*1024*1024;//磁盘缓存大小为50M File diskCacheDir = getDiskCacheDir("bitmap");//此方法需要通过22处理 if(!diskCacheDir.exists()){   diskCacheDir.mkdirs(); } //创建对象 D...
Android编译时报错error: object directory /home/lingnan/Disk2/TianWeiXing_mirror/q-common/LINUX/android/vendor/qcom/proprietary.git/objects does not exist; check .git/objects/info/alternates.
06-13
这个错误提示说明在编译Android时，编译器找不到一个叫做`/home/lingnan/Disk2/TianWeiXing_mirror/q-common/LINUX/android/vendor/qcom/proprietary.git/objects`的目录。这个目录可能被误删或者不存在。 你可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

村里小码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值