Page MenuHomeFreeBSD
Differential D2036

science/rubygem-ruby-dcl: Add port
ClosedPublic
Actions

Authored by xmj on Mar 9 2015, 4:26 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 7, 4:10 AM
Unknown Object (File)
Sun, Mar 23, 9:28 AM
Unknown Object (File)
Fri, Mar 14, 9:29 AM
Unknown Object (File)
Mar 9 2025, 11:52 AM
Unknown Object (File)
Feb 6 2025, 2:16 AM
Unknown Object (File)
Jan 16 2025, 1:33 PM
Unknown Object (File)
Jan 3 2025, 11:51 AM
Unknown Object (File)
Jan 1 2025, 3:33 AM
View All Files
Subscribers
None

Details

Reviewers
xmj
Summary

science/rubygem-ruby-dcl: Add port

This is a Ruby interface to the scientific graphic library DCL.

WWW: http://ruby.gfd-dennou.org/products/ruby-dcl/

Test Plan

http://xmj.me/freebsd/buildlogs/rubygem-ruby-dcl-1.7.0.2.log

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

xmj updated this revision to Diff 4161.Mar 9 2015, 4:26 PM
xmj retitled this revision from to science/rubygem-ruby-dcl: Add port.
xmj updated this object.
xmj edited the test plan for this revision. (Show Details)
xmj accepted this revision.Mar 9 2015, 4:59 PM
xmj added a reviewer: xmj.
This revision is now accepted and ready to land.Mar 9 2015, 4:59 PM
xmj closed this revision.Mar 9 2015, 4:59 PM

Committed revision 380869.

Revision Contents
Changeset List

PathSize
science/
1 line
26 lines
2 lines
3 lines

Diff 4161

View Options

science/Makefile

Show First 20 Lines • Show All 1,401 Lines • ▼ Show 20 Linesdointr(unsigned int interval, int reps)
xo_close_container("interrupt-statistics"); xo_close_container("interrupt-statistics");
} }
static void static void
domemstat_malloc(void) domemstat_malloc(void)
{ {
struct memory_type_list *mtlp; struct memory_type_list *mtlp;
struct memory_type *mtp; struct memory_type *mtp;
int error, first, i; size_t i, zones;
int error, first;
mtlp = memstat_mtl_alloc(); mtlp = memstat_mtl_alloc();
if (mtlp == NULL) { if (mtlp == NULL) {
xo_warn("memstat_mtl_alloc"); xo_warn("memstat_mtl_alloc");
return; return;
} }
if (kd == NULL) { if (kd == NULL) {
if (memstat_sysctl_malloc(mtlp, 0) < 0) { if (memstat_sysctl_malloc(mtlp, 0) < 0) {
xo_warnx("memstat_sysctl_malloc: %s", xo_warnx("memstat_sysctl_malloc: %s",
memstat_strerror(memstat_mtl_geterror(mtlp))); memstat_strerror(memstat_mtl_geterror(mtlp)));
return; return;
} }
markjUnsubmitted
Not Done
Inline Actions

This won't work if running against a vmcore.

markj: This won't work if running against a vmcore.
} else { } else {
if (memstat_kvm_malloc(mtlp, kd) < 0) { if (memstat_kvm_malloc(mtlp, kd) < 0) {
error = memstat_mtl_geterror(mtlp); error = memstat_mtl_geterror(mtlp);
if (error == MEMSTAT_ERROR_KVM) if (error == MEMSTAT_ERROR_KVM)
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
kvm_geterr(kd)); kvm_geterr(kd));
else else
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
memstat_strerror(error)); memstat_strerror(error));
} }
} }
xo_open_container("malloc-statistics"); xo_open_container("malloc-statistics");
xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n", xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n",
"Type", "InUse", "MemUse", "HighUse", "Requests"); "Type", "InUse", "MemUse", "HighUse", "Requests");
xo_open_list("memory"); xo_open_list("memory");
zones = memstat_malloc_zone_get_count();
for (mtp = memstat_mtl_first(mtlp); mtp != NULL; for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
mtp = memstat_mtl_next(mtp)) { mtp = memstat_mtl_next(mtp)) {
if (memstat_get_numallocs(mtp) == 0 && if (memstat_get_numallocs(mtp) == 0 &&
memstat_get_count(mtp) == 0) memstat_get_count(mtp) == 0)
continue; continue;
xo_open_instance("memory"); xo_open_instance("memory");
xo_emit("{k:type/%13s/%s} {:in-use/%5ju} " xo_emit("{k:type/%13s/%s} {:in-use/%5ju} "
"{:memory-use/%5ju}{U:K} {:high-use/%7s} " "{:memory-use/%5ju}{U:K} {:high-use/%7s} "
"{:requests/%8ju} ", "{:requests/%8ju} ",
memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp), memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp),
((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-", ((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-",
(uintmax_t)memstat_get_numallocs(mtp)); (uintmax_t)memstat_get_numallocs(mtp));
first = 1; first = 1;
xo_open_list("size"); xo_open_list("size");
for (i = 0; i < 32; i++) { for (i = 0; i < zones; i++) {
if (memstat_get_sizemask(mtp) & (1 << i)) { if (memstat_malloc_zone_used(mtp, i)) {
if (!first) if (!first)
xo_emit(","); xo_emit(",");
xo_emit("{l:size/%d}", 1 << (i + 4)); xo_emit("{l:size/%d}", memstat_malloc_zone_get_size(i));
first = 0; first = 0;
} }
} }
xo_close_list("size"); xo_close_list("size");
xo_close_instance("memory"); xo_close_instance("memory");
xo_emit("\n"); xo_emit("\n");
} }
xo_close_list("memory"); xo_close_list("memory");
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines
View Options

science/rubygem-ruby-dcl/

Show First 20 Lines • Show All 1,401 Lines • ▼ Show 20 Linesdointr(unsigned int interval, int reps)
xo_close_container("interrupt-statistics"); xo_close_container("interrupt-statistics");
} }
static void static void
domemstat_malloc(void) domemstat_malloc(void)
{ {
struct memory_type_list *mtlp; struct memory_type_list *mtlp;
struct memory_type *mtp; struct memory_type *mtp;
int error, first, i; size_t i, zones;
int error, first;
mtlp = memstat_mtl_alloc(); mtlp = memstat_mtl_alloc();
if (mtlp == NULL) { if (mtlp == NULL) {
xo_warn("memstat_mtl_alloc"); xo_warn("memstat_mtl_alloc");
return; return;
} }
if (kd == NULL) { if (kd == NULL) {
if (memstat_sysctl_malloc(mtlp, 0) < 0) { if (memstat_sysctl_malloc(mtlp, 0) < 0) {
xo_warnx("memstat_sysctl_malloc: %s", xo_warnx("memstat_sysctl_malloc: %s",
memstat_strerror(memstat_mtl_geterror(mtlp))); memstat_strerror(memstat_mtl_geterror(mtlp)));
return; return;
} }
markjUnsubmitted
Not Done
Inline Actions

This won't work if running against a vmcore.

markj: This won't work if running against a vmcore.
} else { } else {
if (memstat_kvm_malloc(mtlp, kd) < 0) { if (memstat_kvm_malloc(mtlp, kd) < 0) {
error = memstat_mtl_geterror(mtlp); error = memstat_mtl_geterror(mtlp);
if (error == MEMSTAT_ERROR_KVM) if (error == MEMSTAT_ERROR_KVM)
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
kvm_geterr(kd)); kvm_geterr(kd));
else else
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
memstat_strerror(error)); memstat_strerror(error));
} }
} }
xo_open_container("malloc-statistics"); xo_open_container("malloc-statistics");
xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n", xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n",
"Type", "InUse", "MemUse", "HighUse", "Requests"); "Type", "InUse", "MemUse", "HighUse", "Requests");
xo_open_list("memory"); xo_open_list("memory");
zones = memstat_malloc_zone_get_count();
for (mtp = memstat_mtl_first(mtlp); mtp != NULL; for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
mtp = memstat_mtl_next(mtp)) { mtp = memstat_mtl_next(mtp)) {
if (memstat_get_numallocs(mtp) == 0 && if (memstat_get_numallocs(mtp) == 0 &&
memstat_get_count(mtp) == 0) memstat_get_count(mtp) == 0)
continue; continue;
xo_open_instance("memory"); xo_open_instance("memory");
xo_emit("{k:type/%13s/%s} {:in-use/%5ju} " xo_emit("{k:type/%13s/%s} {:in-use/%5ju} "
"{:memory-use/%5ju}{U:K} {:high-use/%7s} " "{:memory-use/%5ju}{U:K} {:high-use/%7s} "
"{:requests/%8ju} ", "{:requests/%8ju} ",
memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp), memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp),
((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-", ((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-",
(uintmax_t)memstat_get_numallocs(mtp)); (uintmax_t)memstat_get_numallocs(mtp));
first = 1; first = 1;
xo_open_list("size"); xo_open_list("size");
for (i = 0; i < 32; i++) { for (i = 0; i < zones; i++) {
if (memstat_get_sizemask(mtp) & (1 << i)) { if (memstat_malloc_zone_used(mtp, i)) {
if (!first) if (!first)
xo_emit(","); xo_emit(",");
xo_emit("{l:size/%d}", 1 << (i + 4)); xo_emit("{l:size/%d}", memstat_malloc_zone_get_size(i));
first = 0; first = 0;
} }
} }
xo_close_list("size"); xo_close_list("size");
xo_close_instance("memory"); xo_close_instance("memory");
xo_emit("\n"); xo_emit("\n");
} }
xo_close_list("memory"); xo_close_list("memory");
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines
View Options

science/rubygem-ruby-dcl/Makefile

Show First 20 Lines • Show All 1,401 Lines • ▼ Show 20 Linesdointr(unsigned int interval, int reps)
xo_close_container("interrupt-statistics"); xo_close_container("interrupt-statistics");
} }
static void static void
domemstat_malloc(void) domemstat_malloc(void)
{ {
struct memory_type_list *mtlp; struct memory_type_list *mtlp;
struct memory_type *mtp; struct memory_type *mtp;
int error, first, i; size_t i, zones;
int error, first;
mtlp = memstat_mtl_alloc(); mtlp = memstat_mtl_alloc();
if (mtlp == NULL) { if (mtlp == NULL) {
xo_warn("memstat_mtl_alloc"); xo_warn("memstat_mtl_alloc");
return; return;
} }
if (kd == NULL) { if (kd == NULL) {
if (memstat_sysctl_malloc(mtlp, 0) < 0) { if (memstat_sysctl_malloc(mtlp, 0) < 0) {
xo_warnx("memstat_sysctl_malloc: %s", xo_warnx("memstat_sysctl_malloc: %s",
memstat_strerror(memstat_mtl_geterror(mtlp))); memstat_strerror(memstat_mtl_geterror(mtlp)));
return; return;
} }
markjUnsubmitted
Not Done
Inline Actions

This won't work if running against a vmcore.

markj: This won't work if running against a vmcore.
} else { } else {
if (memstat_kvm_malloc(mtlp, kd) < 0) { if (memstat_kvm_malloc(mtlp, kd) < 0) {
error = memstat_mtl_geterror(mtlp); error = memstat_mtl_geterror(mtlp);
if (error == MEMSTAT_ERROR_KVM) if (error == MEMSTAT_ERROR_KVM)
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
kvm_geterr(kd)); kvm_geterr(kd));
else else
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
memstat_strerror(error)); memstat_strerror(error));
} }
} }
xo_open_container("malloc-statistics"); xo_open_container("malloc-statistics");
xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n", xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n",
"Type", "InUse", "MemUse", "HighUse", "Requests"); "Type", "InUse", "MemUse", "HighUse", "Requests");
xo_open_list("memory"); xo_open_list("memory");
zones = memstat_malloc_zone_get_count();
for (mtp = memstat_mtl_first(mtlp); mtp != NULL; for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
mtp = memstat_mtl_next(mtp)) { mtp = memstat_mtl_next(mtp)) {
if (memstat_get_numallocs(mtp) == 0 && if (memstat_get_numallocs(mtp) == 0 &&
memstat_get_count(mtp) == 0) memstat_get_count(mtp) == 0)
continue; continue;
xo_open_instance("memory"); xo_open_instance("memory");
xo_emit("{k:type/%13s/%s} {:in-use/%5ju} " xo_emit("{k:type/%13s/%s} {:in-use/%5ju} "
"{:memory-use/%5ju}{U:K} {:high-use/%7s} " "{:memory-use/%5ju}{U:K} {:high-use/%7s} "
"{:requests/%8ju} ", "{:requests/%8ju} ",
memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp), memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp),
((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-", ((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-",
(uintmax_t)memstat_get_numallocs(mtp)); (uintmax_t)memstat_get_numallocs(mtp));
first = 1; first = 1;
xo_open_list("size"); xo_open_list("size");
for (i = 0; i < 32; i++) { for (i = 0; i < zones; i++) {
if (memstat_get_sizemask(mtp) & (1 << i)) { if (memstat_malloc_zone_used(mtp, i)) {
if (!first) if (!first)
xo_emit(","); xo_emit(",");
xo_emit("{l:size/%d}", 1 << (i + 4)); xo_emit("{l:size/%d}", memstat_malloc_zone_get_size(i));
first = 0; first = 0;
} }
} }
xo_close_list("size"); xo_close_list("size");
xo_close_instance("memory"); xo_close_instance("memory");
xo_emit("\n"); xo_emit("\n");
} }
xo_close_list("memory"); xo_close_list("memory");
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines
View Options

science/rubygem-ruby-dcl/distinfo

Show First 20 Lines • Show All 1,401 Lines • ▼ Show 20 Linesdointr(unsigned int interval, int reps)
xo_close_container("interrupt-statistics"); xo_close_container("interrupt-statistics");
} }
static void static void
domemstat_malloc(void) domemstat_malloc(void)
{ {
struct memory_type_list *mtlp; struct memory_type_list *mtlp;
struct memory_type *mtp; struct memory_type *mtp;
int error, first, i; size_t i, zones;
int error, first;
mtlp = memstat_mtl_alloc(); mtlp = memstat_mtl_alloc();
if (mtlp == NULL) { if (mtlp == NULL) {
xo_warn("memstat_mtl_alloc"); xo_warn("memstat_mtl_alloc");
return; return;
} }
if (kd == NULL) { if (kd == NULL) {
if (memstat_sysctl_malloc(mtlp, 0) < 0) { if (memstat_sysctl_malloc(mtlp, 0) < 0) {
xo_warnx("memstat_sysctl_malloc: %s", xo_warnx("memstat_sysctl_malloc: %s",
memstat_strerror(memstat_mtl_geterror(mtlp))); memstat_strerror(memstat_mtl_geterror(mtlp)));
return; return;
} }
markjUnsubmitted
Not Done
Inline Actions

This won't work if running against a vmcore.

markj: This won't work if running against a vmcore.
} else { } else {
if (memstat_kvm_malloc(mtlp, kd) < 0) { if (memstat_kvm_malloc(mtlp, kd) < 0) {
error = memstat_mtl_geterror(mtlp); error = memstat_mtl_geterror(mtlp);
if (error == MEMSTAT_ERROR_KVM) if (error == MEMSTAT_ERROR_KVM)
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
kvm_geterr(kd)); kvm_geterr(kd));
else else
xo_warnx("memstat_kvm_malloc: %s", xo_warnx("memstat_kvm_malloc: %s",
memstat_strerror(error)); memstat_strerror(error));
} }
} }
xo_open_container("malloc-statistics"); xo_open_container("malloc-statistics");
xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n", xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n",
"Type", "InUse", "MemUse", "HighUse", "Requests"); "Type", "InUse", "MemUse", "HighUse", "Requests");
xo_open_list("memory"); xo_open_list("memory");
zones = memstat_malloc_zone_get_count();
for (mtp = memstat_mtl_first(mtlp); mtp != NULL; for (mtp = memstat_mtl_first(mtlp); mtp != NULL;
mtp = memstat_mtl_next(mtp)) { mtp = memstat_mtl_next(mtp)) {
if (memstat_get_numallocs(mtp) == 0 && if (memstat_get_numallocs(mtp) == 0 &&
memstat_get_count(mtp) == 0) memstat_get_count(mtp) == 0)
continue; continue;
xo_open_instance("memory"); xo_open_instance("memory");
xo_emit("{k:type/%13s/%s} {:in-use/%5ju} " xo_emit("{k:type/%13s/%s} {:in-use/%5ju} "
"{:memory-use/%5ju}{U:K} {:high-use/%7s} " "{:memory-use/%5ju}{U:K} {:high-use/%7s} "
"{:requests/%8ju} ", "{:requests/%8ju} ",
memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp), memstat_get_name(mtp), (uintmax_t)memstat_get_count(mtp),
((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-", ((uintmax_t)memstat_get_bytes(mtp) + 1023) / 1024, "-",
(uintmax_t)memstat_get_numallocs(mtp)); (uintmax_t)memstat_get_numallocs(mtp));
first = 1; first = 1;
xo_open_list("size"); xo_open_list("size");
for (i = 0; i < 32; i++) { for (i = 0; i < zones; i++) {
if (memstat_get_sizemask(mtp) & (1 << i)) { if (memstat_malloc_zone_used(mtp, i)) {
if (!first) if (!first)
xo_emit(","); xo_emit(",");
xo_emit("{l:size/%d}", 1 << (i + 4)); xo_emit("{l:size/%d}", memstat_malloc_zone_get_size(i));
first = 0; first = 0;
} }
} }
xo_close_list("size"); xo_close_list("size");
xo_close_instance("memory"); xo_close_instance("memory");
xo_emit("\n"); xo_emit("\n");
} }
xo_close_list("memory"); xo_close_list("memory");
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines
View Options

science/rubygem-ruby-dcl/pkg-descr

Loading...