int
main(int argc, char *argv[])
{
std::string &&astr = return_a_string();
std::cout << std::addressof(astr) << ": " << astr << std::endl;
print_ref(astr);
print_ref(return_a_string());
foo(bar());
int hoge = 777;
int &&fuga = std::move(hoge);
fuga = 7777;
std::cout << std::addressof(hoge) << ": " << hoge << std::endl;
std::cout << std::addressof(fuga) << ": " << fuga << std::endl;
C a;
C b(777, "b");
C c(b);
C d(std::move(b));
return 0;
}
static int ref_test(IC_Env *env)
{
erlang_ref refi = { "node1", 3, {1, 2, 3}, 1},
refo, refr;
fprintf(stdout, "\n======== m_i_ref test ======\n\n");
refr = m_i_ref_test(NULL, &refi, &refo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_ref(&refi, &refo) && cmp_ref(&refi, &refr));
if (!cmp_ref(&refi, &refo)) {
fprintf(stdout, " out parameter error, sent:\n");
print_ref(&refi);
fprintf(stdout, "got:\n");
print_ref(&refo);
}
if (!cmp_ref(&refi, &refr)) {
fprintf(stdout, " result error, sent:\n");
print_ref(&refi);
fprintf(stdout, "got:\n");
print_ref(&refr);
}
return -1;
}
int main(int argc, char** argv) {
gv_set_ref(0, 0, 0);
set_ref(0., 0., 0.);
int i = 0;
while (i<NB_STEP) {
int32_t sp_i = get_sp(i);
// gv_update_ref_from_z_sp(sp_i);
gv_update_ref_from_zd_sp(sp_i);
// z_sp = BOOZ_FLOAT_OF_INT(sp_i, IPOS_FRAC);
// update_ref_from_z();
zd_sp = BOOZ_FLOAT_OF_INT(sp_i, ISPEED_RES);
update_ref_from_zd();
print_ref(i);
i++;
}
return 0;
}
/*
* Find/display global/local variables which own the most heap memory in bytes
*/
CA_BOOL biggest_heap_owners_generic(unsigned int num, CA_BOOL all_reachable_blocks)
{
CA_BOOL rc = CA_FALSE;
unsigned int i;
int nregs = 0;
struct reg_value *regs_buf = NULL;
size_t ptr_sz = g_ptr_bit >> 3;
struct heap_owner *owners;
struct heap_owner *smallest;
struct ca_segment *segment;
size_t total_bytes = 0;
size_t processed_bytes = 0;
struct inuse_block *inuse_blocks = NULL;
unsigned long num_inuse_blocks;
unsigned long inuse_index;
struct inuse_block *blk;
struct object_reference ref;
size_t aggr_size;
unsigned long aggr_count;
address_t start, end, cursor;
// Allocate an array for the biggest num of owners
if (num == 0)
return CA_FALSE;
owners = (struct heap_owner *) calloc(num, sizeof(struct heap_owner));
if (!owners)
goto clean_out;
smallest = &owners[num - 1];
// First, create and populate an array of all in-use blocks
inuse_blocks = build_inuse_heap_blocks(&num_inuse_blocks);
if (!inuse_blocks || num_inuse_blocks == 0)
{
CA_PRINT("Failed: no in-use heap block is found\n");
goto clean_out;
}
// estimate the work to enable progress bar
for (i=0; i<g_segment_count; i++)
{
segment = &g_segments[i];
if (segment->m_type == ENUM_STACK || segment->m_type == ENUM_MODULE_DATA)
total_bytes += segment->m_fsize;
}
init_progress_bar(total_bytes);
// Walk through all segments of threads' registers/stacks or globals
for (i=0; i<g_segment_count; i++)
{
// bail out if user is impatient for the long searching
if (user_request_break())
{
CA_PRINT("Abort searching biggest heap memory owners\n");
goto clean_out;
}
// Only thread stack and global .data sections are considered
segment = &g_segments[i];
if (segment->m_type == ENUM_STACK || segment->m_type == ENUM_MODULE_DATA)
{
int tid = 0;
// check registers if it is a thread's stack segment
if (segment->m_type == ENUM_STACK)
{
tid = get_thread_id (segment);
// allocate register value buffer for once
if (!nregs && !regs_buf)
{
nregs = read_registers (NULL, NULL, 0);
if (nregs)
regs_buf = (struct reg_value*) malloc(nregs * sizeof(struct reg_value));
}
// check each register for heap reference
if (nregs && regs_buf)
{
int k;
int nread = read_registers (segment, regs_buf, nregs);
for (k = 0; k < nread; k++)
{
if (regs_buf[k].reg_width == ptr_sz)
{
blk = find_inuse_block(regs_buf[k].value, inuse_blocks, num_inuse_blocks);
if (blk)
{
ref.storage_type = ENUM_REGISTER;
ref.vaddr = 0;
ref.value = blk->addr;
ref.where.reg.tid = tid;
ref.where.reg.reg_num = k;
ref.where.reg.name = NULL;
calc_aggregate_size(&ref, ptr_sz, all_reachable_blocks, inuse_blocks, num_inuse_blocks, &aggr_size, &aggr_count);
if (aggr_size > smallest->aggr_size)
{
struct heap_owner newowner;
newowner.ref = ref;
newowner.aggr_size = aggr_size;
newowner.aggr_count = aggr_count;
add_owner(owners, num, &newowner);
}
}
}
}
}
}
// Calculate the memory region to search
if (segment->m_type == ENUM_STACK)
{
start = get_rsp(segment);
if (start < segment->m_vaddr || start >= segment->m_vaddr + segment->m_vsize)
start = segment->m_vaddr;
if (start - segment->m_vaddr >= segment->m_fsize)
end = start;
else
end = segment->m_vaddr + segment->m_fsize;
}
else if (segment->m_type == ENUM_MODULE_DATA)
{
start = segment->m_vaddr;
end = segment->m_vaddr + segment->m_fsize;
}
else
continue;
// Evaluate each variable or raw pointer in the target memory region
cursor = ALIGN(start, ptr_sz);
while (cursor < end)
{
size_t val_len = ptr_sz;
address_t sym_addr;
size_t sym_sz;
CA_BOOL known_sym = CA_FALSE;
// If the address belongs to a known variable, include all its subfields
// FIXME
// consider subfields that are of pointer-like types, however, it will miss
// references in an unstructured buffer
ref.storage_type = segment->m_type;
ref.vaddr = cursor;
if (segment->m_type == ENUM_STACK)
{
ref.where.stack.tid = tid;
ref.where.stack.frame = get_frame_number(segment, cursor, &ref.where.stack.offset);
if (known_stack_sym(&ref, &sym_addr, &sym_sz) && sym_sz)
known_sym = CA_TRUE;
}
else if (segment->m_type == ENUM_MODULE_DATA)
{
ref.where.module.base = segment->m_vaddr;
ref.where.module.size = segment->m_vsize;
ref.where.module.name = segment->m_module_name;
if (known_global_sym(&ref, &sym_addr, &sym_sz) && sym_sz)
known_sym = CA_TRUE;
}
if (known_sym)
{
if (cursor != sym_addr)
ref.vaddr = cursor = sym_addr; // we should never come to here!
val_len = sym_sz;
}
// Query heap for aggregated memory size/count originated from the candidate variable
if (val_len >= ptr_sz)
{
calc_aggregate_size(&ref, val_len, all_reachable_blocks, inuse_blocks, num_inuse_blocks, &aggr_size, &aggr_count);
// update the top list if applies
if (aggr_size >= smallest->aggr_size)
{
struct heap_owner newowner;
if (val_len == ptr_sz)
read_memory_wrapper(NULL, ref.vaddr, (void*)&ref.value, ptr_sz);
else
ref.value = 0;
newowner.ref = ref;
newowner.aggr_size = aggr_size;
newowner.aggr_count = aggr_count;
add_owner(owners, num, &newowner);
}
}
cursor = ALIGN(cursor + val_len, ptr_sz);
}
processed_bytes += segment->m_fsize;
set_current_progress(processed_bytes);
}
}
end_progress_bar();
if (!all_reachable_blocks)
{
// Big memory blocks may be referenced indirectly by local/global variables
// check all in-use blocks
for (inuse_index = 0; inuse_index < num_inuse_blocks; inuse_index++)
{
blk = &inuse_blocks[inuse_index];
ref.storage_type = ENUM_HEAP;
ref.vaddr = blk->addr;
ref.where.heap.addr = blk->addr;
ref.where.heap.size = blk->size;
ref.where.heap.inuse = 1;
calc_aggregate_size(&ref, ptr_sz, CA_FALSE, inuse_blocks, num_inuse_blocks, &aggr_size, &aggr_count);
// update the top list if applies
if (aggr_size >= smallest->aggr_size)
{
struct heap_owner newowner;
ref.value = 0;
newowner.ref = ref;
newowner.aggr_size = aggr_size;
newowner.aggr_count = aggr_count;
add_owner(owners, num, &newowner);
}
}
}
// Print the result
for (i = 0; i < num; i++)
{
struct heap_owner *owner = &owners[i];
if (owner->aggr_size)
{
CA_PRINT("[%d] ", i+1);
print_ref(&owner->ref, 0, CA_FALSE, CA_FALSE);
CA_PRINT(" |--> ");
print_size(owner->aggr_size);
CA_PRINT(" (%ld blocks)\n", owner->aggr_count);
}
}
rc = CA_TRUE;
clean_out:
// clean up
if (regs_buf)
free (regs_buf);
if (owners)
free (owners);
if (inuse_blocks)
free_inuse_heap_blocks (inuse_blocks, num_inuse_blocks);
return rc;
}
static int handle_docline (char *l, FILE *out, int docstat)
{
char buff[BUFFSIZE];
char *s, *d;
l = skip_ws (l);
if (Debug)
fprintf (stderr, "%s: handle_docline `%s'\n", Progname, l);
if (!strncmp (l, ".pp", 3))
return print_it (SP_NEWPAR, NULL, out, docstat);
else if (!strncmp (l, ".ts", 3))
return print_it (SP_START_TAB, NULL, out, docstat);
else if (!strncmp (l, ".te", 3))
return print_it (SP_END_TAB, NULL, out, docstat);
else if (!strncmp (l, ".dl", 3))
return print_it (SP_START_DL, NULL, out, docstat);
else if (!strncmp (l, ".de", 3))
return print_it (SP_END_DL, NULL, out, docstat);
else if (!strncmp (l, ".il", 3))
return print_it (SP_START_IL, NULL, out, docstat);
else if (!strncmp (l, ".ie", 3))
return print_it (SP_END_IL, NULL, out, docstat);
else if (!strncmp (l, ". ", 2))
*l = ' ';
for (s = l, d = buff; *s; s++)
{
if (!strncmp (s, "\\(as", 4))
{
*d++ = '*';
s += 3;
}
else if (!strncmp (s, "\\(rs", 4))
{
*d++ = '\\';
s += 3;
}
else if (!strncmp (s, "\\fI", 3))
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_START_EM, NULL, out, docstat);
s += 2;
}
else if (!strncmp (s, "\\fB", 3))
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_START_BF, NULL, out, docstat);
s += 2;
}
else if (!strncmp (s, "\\fC", 3))
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_START_TT, NULL, out, docstat);
s += 2;
}
else if (!strncmp (s, "\\fP", 3))
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_END_FT, NULL, out, docstat);
s += 2;
}
else if (!strncmp (s, ".dt", 3))
{
if (docstat & D_DD)
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_END_DD, NULL, out, docstat);
}
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_DT, NULL, out, docstat);
s += 3;
}
else if (!strncmp (s, ".dd", 3))
{
if ((docstat & D_IL) && (docstat & D_DD))
{
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_END_DD, NULL, out, docstat);
}
docstat = commit_buff (buff, &d, out, docstat);
docstat = print_it (SP_DD, NULL, out, docstat);
s += 3;
}
else if (*s == '$')
{
int output_dollar = 0;
char *ref;
char save;
++s;
if (*s == '$')
{
output_dollar = 1;
++s;
}
if (*s == '$')
{
*d++ = '$';
}
else
{
ref = s;
while (isalnum ((unsigned char) *s) || (*s && strchr("-_<>", *s)))
++s;
docstat = commit_buff (buff, &d, out, docstat);
save = *s;
*s = 0;
print_ref (out, output_dollar, ref);
*s = save;
--s;
}
}
else
*d++ = *s;
}
docstat = commit_buff (buff, &d, out, docstat);
return print_it (SP_NEWLINE, NULL, out, docstat);
}
/*-------------------------------------------------------------------------
* Function: test_fill
*
* Purpose: Tests the H5VM_hyper_fill() function.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_fill(size_t nx, size_t ny, size_t nz,
size_t di, size_t dj, size_t dk,
size_t ddx, size_t ddy, size_t ddz)
{
uint8_t *dst = NULL; /*destination array */
hsize_t hs_size[3]; /*hyperslab size */
hsize_t dst_size[3]; /*destination total size */
hsize_t dst_offset[3]; /*offset of hyperslab in dest */
unsigned ref_value; /*reference value */
unsigned acc; /*accumulator */
size_t i, j, k, dx, dy, dz; /*counters */
size_t u, v, w;
unsigned ndims; /*hyperslab dimensionality */
char dim[64], s[256]; /*temp string */
unsigned fill_value; /*fill value */
/*
* Dimensionality.
*/
if(0 == nz) {
if(0 == ny) {
ndims = 1;
ny = nz = 1;
sprintf(dim, "%lu", (unsigned long) nx);
} /* end if */
else {
ndims = 2;
nz = 1;
sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
} /* end else */
} /* end if */
else {
ndims = 3;
sprintf(dim, "%lux%lux%lu", (unsigned long) nx, (unsigned long) ny,
(unsigned long) nz);
} /* end else */
sprintf(s, "Testing hyperslab fill %-11s variable hyperslab", dim);
printf("%-70s", s);
fflush(stdout);
/* Allocate array */
if(NULL == (dst = (uint8_t *)HDcalloc((size_t)1, nx * ny * nz)))
TEST_ERROR
init_full(dst, nx, ny, nz);
for(i = 0; i < nx; i += di) {
for(j = 0; j < ny; j += dj) {
for(k = 0; k < nz; k += dk) {
for(dx = 1; dx <= nx - i; dx += ddx) {
for(dy = 1; dy <= ny - j; dy += ddy) {
for(dz = 1; dz <= nz - k; dz += ddz) {
/* Describe the hyperslab */
dst_size[0] = nx;
dst_size[1] = ny;
dst_size[2] = nz;
dst_offset[0] = i;
dst_offset[1] = j;
dst_offset[2] = k;
hs_size[0] = dx;
hs_size[1] = dy;
hs_size[2] = dz;
for(fill_value = 0; fill_value < 256; fill_value += 64) {
/*
* Initialize the full array, then subtract the
* original * fill values and add the new ones.
*/
ref_value = init_full(dst, nx, ny, nz);
for(u = (size_t)dst_offset[0]; u < dst_offset[0] + dx; u++)
for(v = (size_t)dst_offset[1]; v < dst_offset[1] + dy; v++)
for(w = (size_t)dst_offset[2]; w < dst_offset[2] + dz; w++)
ref_value -= dst[u * ny * nz + v * nz + w];
ref_value += fill_value * (unsigned)dx * (unsigned)dy * (unsigned)dz;
/* Fill the hyperslab with some value */
H5VM_hyper_fill(ndims, hs_size, dst_size, dst_offset, dst, fill_value);
/*
* Sum the array and compare it to the
* reference value.
*/
acc = 0;
for(u = 0; u < nx; u++)
for(v = 0; v < ny; v++)
for(w = 0; w < nz; w++)
acc += dst[u * ny * nz + v * nz + w];
if(acc != ref_value) {
H5_FAILED()
if(!HDisatty(1)) {
/*
* Print debugging info unless output
* is going directly to a terminal.
*/
AT();
printf(" acc != ref_value\n");
printf(" i=%lu, j=%lu, k=%lu, "
"dx=%lu, dy=%lu, dz=%lu, "
"fill=%d\n", (unsigned long)i,
(unsigned long)j,
(unsigned long)k,
(unsigned long)dx,
(unsigned long)dy,
(unsigned long)dz, fill_value);
print_ref(nx, ny, nz);
printf("\n Result is:\n");
print_array(dst, nx, ny, nz);
} /* end if */
goto error;
} /* end if */
} /* end for */
} /* end for */
} /* end for */
} /* end for */
} /* end for */
} /* end for */
} /* end for */
