C++ (Cpp) memstat_mtl_first Examples

Example #1

File: vmstat.c Project: moscaliucpaulandrei/freebsd

static void
domemstat_malloc(void)
{
	struct memory_type_list *mtlp;
	struct memory_type *mtp;
	int error, first, i;

	mtlp = memstat_mtl_alloc();
	if (mtlp == NULL) {
		warn("memstat_mtl_alloc");
		return;
	}
	if (kd == NULL) {
		if (memstat_sysctl_malloc(mtlp, 0) < 0) {
			warnx("memstat_sysctl_malloc: %s",
			    memstat_strerror(memstat_mtl_geterror(mtlp)));
			return;
		}
	} else {
		if (memstat_kvm_malloc(mtlp, kd) < 0) {
			error = memstat_mtl_geterror(mtlp);
			if (error == MEMSTAT_ERROR_KVM)
				warnx("memstat_kvm_malloc: %s",
				    kvm_geterr(kd));
			else
				warnx("memstat_kvm_malloc: %s",
				    memstat_strerror(error));
		}
	}
	printf("%13s %5s %6s %7s %8s  Size(s)\n", "Type", "InUse", "MemUse",
	    "HighUse", "Requests");
	for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
	    mtp = memstat_mtl_next(mtp)) {
		if (memstat_get_numallocs(mtp) == 0 &&
		    memstat_get_count(mtp) == 0)
			continue;
		printf("%13s %5" PRIu64 " %5" PRIu64 "K %7s %8" PRIu64 "  ",
		    memstat_get_name(mtp), memstat_get_count(mtp),
		    (memstat_get_bytes(mtp) + 1023) / 1024, "-",
		    memstat_get_numallocs(mtp));
		first = 1;
		for (i = 0; i < 32; i++) {
			if (memstat_get_sizemask(mtp) & (1 << i)) {
				if (!first)
					printf(",");
				printf("%d", 1 << (i + 4));
				first = 0;
			}
		}
		printf("\n");
	}
	memstat_mtl_free(mtlp);
}

Example #2

File: vmstat.c Project: moscaliucpaulandrei/freebsd

static void
domemstat_zone(void)
{
	struct memory_type_list *mtlp;
	struct memory_type *mtp;
	char name[MEMTYPE_MAXNAME + 1];
	int error;

	mtlp = memstat_mtl_alloc();
	if (mtlp == NULL) {
		warn("memstat_mtl_alloc");
		return;
	}
	if (kd == NULL) {
		if (memstat_sysctl_uma(mtlp, 0) < 0) {
			warnx("memstat_sysctl_uma: %s",
			    memstat_strerror(memstat_mtl_geterror(mtlp)));
			return;
		}
	} else {
		if (memstat_kvm_uma(mtlp, kd) < 0) {
			error = memstat_mtl_geterror(mtlp);
			if (error == MEMSTAT_ERROR_KVM)
				warnx("memstat_kvm_uma: %s",
				    kvm_geterr(kd));
			else
				warnx("memstat_kvm_uma: %s",
				    memstat_strerror(error));
		}
	}
	printf("%-20s %6s %6s %8s %8s %8s %4s %4s\n\n", "ITEM", "SIZE",
	    "LIMIT", "USED", "FREE", "REQ", "FAIL", "SLEEP");
	for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
	    mtp = memstat_mtl_next(mtp)) {
		strlcpy(name, memstat_get_name(mtp), MEMTYPE_MAXNAME);
		strcat(name, ":");
		printf("%-20s %6" PRIu64 ", %6" PRIu64 ",%8" PRIu64 ",%8" PRIu64
		    ",%8" PRIu64 ",%4" PRIu64 ",%4" PRIu64 "\n", name,
		    memstat_get_size(mtp), memstat_get_countlimit(mtp),
		    memstat_get_count(mtp), memstat_get_free(mtp),
		    memstat_get_numallocs(mtp), memstat_get_failures(mtp),
		    memstat_get_sleeps(mtp));
	}
	memstat_mtl_free(mtlp);
	printf("\n");
}

Example #3

static void
storage_OS_get_memstat(void)
{
	struct memory_type *mt_item;
	struct storage_entry *entry;

	if (mt_list == NULL) {
		if ((mt_list = memstat_mtl_alloc()) == NULL)
			/* again? we have a serious problem */
		return;
	}

	if (memstat_sysctl_all(mt_list, 0) < 0) {
		syslog(LOG_ERR, "memstat_sysctl_all failed: %s",
		    memstat_strerror(memstat_mtl_geterror(mt_list)) );
		return;
	}

	if ((mt_item = memstat_mtl_first(mt_list)) == NULL) {
		/* usually this is not an error, no errno for this failure*/
		HRDBG("memstat_mtl_first failed");
		return;
	}

	do {
		const char *memstat_name;
		uint64_t tmp_size;
		int allocator;
		char alloc_descr[SE_DESC_MLEN];

		memstat_name = memstat_get_name(mt_item);

		if (memstat_name == NULL || strlen(memstat_name) == 0)
			continue;

		switch (allocator = memstat_get_allocator(mt_item)) {

		  case ALLOCATOR_MALLOC:
			snprintf(alloc_descr, sizeof(alloc_descr),
			    "MALLOC: %s", memstat_name);
			break;

		  case ALLOCATOR_UMA:
			snprintf(alloc_descr, sizeof(alloc_descr),
			    "UMA: %s", memstat_name);
			break;

		  default:
			snprintf(alloc_descr, sizeof(alloc_descr),
			    "UNKNOWN%d: %s", allocator, memstat_name);
			break;
		}

		if ((entry = storage_find_by_name(alloc_descr)) == NULL &&
		    (entry = storage_entry_create(alloc_descr)) == NULL)
			return;

		entry->flags |= HR_STORAGE_FOUND;
		entry->type = &OIDX_hrStorageRam_c;

		if ((tmp_size = memstat_get_size(mt_item)) == 0)
			tmp_size = memstat_get_sizemask(mt_item);
		entry->allocationUnits =
		    (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);

		tmp_size  = memstat_get_countlimit(mt_item);
		entry->size =
		    (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);

		tmp_size = memstat_get_count(mt_item);
		entry->used =
		    (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);

		tmp_size = memstat_get_failures(mt_item);
		entry->allocationFailures =
		    (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);

	} while((mt_item = memstat_mtl_next(mt_item)) != NULL);
}