/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2001-2012. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* %CopyrightEnd%
*/
/*
* hipe_bif1.c
*
* Performance analysis support.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "sys.h"
#include "global.h"
#include "bif.h"
#include "big.h"
#include "error.h"
#include "beam_load.h"
#include "hipe_bif0.h"
#include "hipe_bif1.h"
#define BeamOpCode(Op) ((Uint)BeamOp(Op))
BIF_RETTYPE hipe_bifs_call_count_on_1(BIF_ALIST_1)
{
Eterm *pc;
struct hipe_call_count *hcc;
pc = hipe_bifs_find_pc_from_mfa(BIF_ARG_1);
if (!pc)
BIF_ERROR(BIF_P, BADARG);
ASSERT(pc[-5] == BeamOpCode(op_i_func_info_IaaI));
if (pc[0] == BeamOpCode(op_hipe_trap_call))
BIF_ERROR(BIF_P, BADARG);
if (pc[0] == BeamOpCode(op_hipe_call_count))
BIF_RET(NIL);
hcc = erts_alloc(ERTS_ALC_T_HIPE, sizeof(*hcc));
hcc->count = 0;
hcc->opcode = pc[0];
pc[-4] = (Eterm)hcc;
pc[0] = BeamOpCode(op_hipe_call_count);
BIF_RET(am_true);
}
BIF_RETTYPE hipe_bifs_call_count_off_1(BIF_ALIST_1)
{
Eterm *pc;
struct hipe_call_count *hcc;
unsigned count;
pc = hipe_bifs_find_pc_from_mfa(BIF_ARG_1);
if (!pc)
BIF_ERROR(BIF_P, BADARG);
ASSERT(pc[-5] == BeamOpCode(op_i_func_info_IaaI));
if (pc[0] != BeamOpCode(op_hipe_call_count))
BIF_RET(am_false);
hcc = (struct hipe_call_count*)pc[-4];
count = hcc->count;
pc[0] = hcc->opcode;
pc[-4] = (Eterm)NULL;
erts_free(ERTS_ALC_T_HIPE, hcc);
BIF_RET(make_small(count));
}
BIF_RETTYPE hipe_bifs_call_count_get_1(BIF_ALIST_1)
{
Eterm *pc;
struct hipe_call_count *hcc;
pc = hipe_bifs_find_pc_from_mfa(BIF_ARG_1);
if (!pc)
BIF_ERROR(BIF_P, BADARG);
ASSERT(pc[-5] == BeamOpCode(op_i_func_info_IaaI));
if (pc[0] != BeamOpCode(op_hipe_call_count))
BIF_RET(am_false);
hcc = (struct hipe_call_count*)pc[-4];
BIF_RET(make_small(hcc->count));
}
BIF_RETTYPE hipe_bifs_call_count_clear_1(BIF_ALIST_1)
{
Eterm *pc;
struct hipe_call_count *hcc;
unsigned count;
pc = hipe_bifs_find_pc_from_mfa(BIF_ARG_1);
if (!pc)
BIF_ERROR(BIF_P, BADARG);
ASSERT(pc[-5] == BeamOpCode(op_i_func_info_IaaI));
if (pc[0] != BeamOpCode(op_hipe_call_count))
BIF_RET(am_false);
hcc = (struct hipe_call_count*)pc[-4];
count = hcc->count;
hcc->count = 0;
BIF_RET(make_small(count));
}
unsigned int hipe_trap_count;
BIF_RETTYPE hipe_bifs_trap_count_get_0(BIF_ALIST_0)
{
BIF_RET(make_small(hipe_trap_count));
}
BIF_RETTYPE hipe_bifs_trap_count_clear_0(BIF_ALIST_0)
{
unsigned int count = hipe_trap_count;
hipe_trap_count = 0;
BIF_RET(make_small(count));
}
/*****************************************************************************
* BIFs for benchmarking. These only do useful things if
* __BENCHMARK__ is defined in beam/benchmark.h. For documentation
* about how to add new counters or maintain the existing counters,
* see benchmark.h.
*
* If benchmarking is not enabled all BIFs will return false. If the
* required benchmark feature is not enabled, the counter will remain
* zero.
*
* process_info/0 -> { Number of live processes,
* Processes spawned in total }
*
* Live processes are increased when a new process is created, and
* decreased when a process dies. Processes spawned is increased
* when a process is created.
*
*
* process_info_clear/0 -> true
*
* Will reset the processes spawned-counters to zero. If this is
* done at some improper time, live processes may become a negative
* value. This is not a problem in itself, just as long as you know
* about it.
*
*
* message_info/0 -> { Messages sent,
* Messages copied,
* Ego messages (sender = receiver),
* Words sent,
* Words copied,
* Words preallocated }
*
* Counting the words sent in a shared heap system will affect
* runtime performance since it means that we have to calculate the
* size of the mesage. With private heaps, this is done anyway and
* will not affect performance.
*
*
* message_info_clear/0 -> true
*
* Reset the message counters to zero.
*
*
* message_sizes/0 -> true
*
* Displays a text-mode bar diagram with message sizes. There are no
* guaranties that this is printed in a way the Erlang system is
* supposed to print things.
*
*
* gc_info/0 -> { Minor collections,
* Major collections,
* Used heap,
* Allocated heap,
* Max used heap,
* Max allocated heap }
*
* Information about private heap garbage collections. Number of
* minor and major collections, how much heap is used and allocated
* and how much heap has been in use and allocated at most since the
* counters were reset.
*
*
* shared_gc_info/0 -> { Minor collections of the shared heap,
* Major collections of the shared heap,
* Used shared heap,
* Allocated shared heap,
* Max used shared heap,
* Max allocated shared heap }
*
* The same as above, but for the shared heap / message area. Note,
* that in a shared heap system the max used heap and max allocated
* heap are mostly the same, since the heap allways is filled before
* a garbage collection, and most garbage collections do not enlarge
* the heap. The private heap numbers are much more interesting.
*
*
* incremental_gc_info/0 -> { Complete minor GC cycles,
* Complete major GC cycles,
* Minor GC stages,
* Major GC stages }
*
*
* gc_info_clear/0 -> true
*
* Reset counters for both private and shared garbage collection.
*
*
* BM Timers
* ---------
*
* All timers returns tuples of the kind: { Minutes, Seconds, Milliseconds }
* except for the max times in garbage collection where times are normally
* small. The tuple is therefor: { Seconds, Milliseconds, Microseconds }
*
* system_timer/0 -> Mutator time
*
* This timer is not a real-time clock, it only runs when a process
* is scheduled to run. You can not find out the accual time a
* program has taken to run using this timer.
*
*
* system_timer_clear/0 -> true
*
* Reset system timer to zero.
*
*
* send_timer/0 -> { Send time,
* Copy time,
* Size time }
*
* Time spent in sending messages. The copy time and size time are
* only active if the copying is needed in send. Copying of data
* into ETS-tables etc is not timed with this timer.
*
*
* send_timer_clear/0 -> true
*
* Reset send timers to zero.
*
*
* gc_timer/0 -> { Time in minor collection,
* Time in major collection,
* Max time in minor collection (�s),
* Max time in major collection (�s) }
*
* Total time spent in garbage collection of the private heaps. The
* max times are for one separate collection.
*
*
* shared_gc_timer/0 -> { Time in minor collection,
* Time in major collection,
* Max time in minor collection (�s),
* Max time in major collection (�s) }
*
* Total time spent in garbage collection of the shared heap /
* message area. The max times are for one separate collection.
*
*
* gc_timer_clear/0 -> true
*
* Reset private and shared garbage collection timers to zero. Note,
* that the max-times are also reset.
*
*
* misc_timer/0 -> { Misc 0, Misc 1, Misc 2 }
*
* Timers for debug purposes. In a normal system, these timers are
* never used. Add these timers at places where you want to time
* something not covered here. Use BM_SWAP_TIMER(from,to) to start
* one of the misc timers.
*
* ... code timed by the system timer ...
* BM_SWAP_TIMER(system,misc1);
* ... code we want to time ...
* BM_SWAP_TIMER(misc1,system);
* ... back on system time ...
*
*
* misc_timer_clear/0 -> true
*
* Reset misc timers to zero.
*/
BIF_RETTYPE hipe_bifs_process_info_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#ifndef BM_COUNTERS
Uint processes_busy = 0;
Uint processes_spawned = 0;
#endif
Eterm *hp;
hp = HAlloc(BIF_P, 3);
BIF_RET(TUPLE2(hp,
make_small(processes_busy),
make_small(processes_spawned)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_process_info_clear_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#ifdef BM_COUNTERS
processes_spawned = 0;
#endif
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_message_info_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
Eterm *hp;
#ifndef BM_COUNTERS
unsigned long messages_sent = 0;
unsigned long messages_copied = 0;
unsigned long messages_ego = 0;
#endif
#ifndef BM_MESSAGE_SIZES
unsigned long words_sent = 0;
unsigned long words_copied = 0;
unsigned long words_prealloc = 0;
#endif
hp = HAlloc(BIF_P, 7);
BIF_RET(TUPLE6(hp,
make_small(messages_sent),
make_small(messages_copied),
make_small(messages_ego),
make_small(words_sent),
make_small(words_copied),
make_small(words_prealloc)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_message_info_clear_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#ifdef BM_COUNTERS
messages_sent = 0;
messages_copied = 0;
messages_ego = 0;
#endif
#ifdef BM_MESSAGE_SIZES
words_sent = 0;
words_copied = 0;
words_prealloc = 0;
{
int i;
for (i = 0; i < 1000; i++)
message_sizes[i] = 0;
}
#endif
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_message_sizes_0(BIF_ALIST_0)
{
#ifdef BM_MESSAGE_SIZES
int i, j, max = 0;
int tmp[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
for (i = 0; i < 65; i++) {
tmp[0] += message_sizes[i];
if (tmp[0] > max)
max = tmp[0];
}
for (i = 65; i < 999; i++) {
tmp[i / 100 + 1] += message_sizes[i];
if (tmp[i / 100 + 1] > max)
max = tmp[i / 100 + 1];
}
tmp[11] = message_sizes[999];
if (tmp[11] > max)
max = tmp[11];
for (i = -1; i < 11; i++) {
int num = (tmp[i + 1] * 50) / max;
if (i == -1)
printf("\n\r 0 - 64: (%6d) |", tmp[0]);
else if (i == 0)
printf("\n\r 65 - 99: (%6d) |", tmp[1]);
else if (i == 10)
printf("\n\r >= 1000: (%6d) |", tmp[11]);
else
printf("\n\r%3d - %3d: (%6d) |", i * 100, i * 100 + 99,
tmp[i + 1]);
for (j = 0; j < num; j++)
printf(".");
}
printf("\n\r");
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_gc_info_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#ifndef BM_COUNTERS
Uint minor_gc = 0;
Uint major_gc = 0;
#endif
#ifndef BM_HEAP_SIZES
Uint max_used_heap = 0;
Uint max_allocated_heap = 0;
#endif
Eterm *hp;
Uint used_heap = (BIF_P->htop - BIF_P->heap) +
(OLD_HTOP(BIF_P) - OLD_HEAP(BIF_P)) +
MBUF_SIZE(BIF_P);
Uint alloc_heap = (BIF_P->hend - BIF_P->heap) +
(OLD_HEND(BIF_P) - OLD_HEAP(BIF_P)) +
MBUF_SIZE(BIF_P);
hp = HAlloc(BIF_P, 7);
BIF_RET(TUPLE6(hp,
make_small((Uint)minor_gc),
make_small((Uint)major_gc),
make_small((Uint)used_heap),
make_small((Uint)alloc_heap),
make_small(max_used_heap),
make_small(max_allocated_heap)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_shared_gc_info_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#if !(defined(BM_COUNTERS))
Uint minor_global_gc = 0;
Uint major_global_gc = 0;
#endif
#ifndef BM_HEAP_SIZES
Uint max_used_global_heap = 0;
Uint max_allocated_global_heap = 0;
#endif
Eterm *hp;
Uint tmp_used_heap = 0;
Uint tmp_allocated_heap = 0;
hp = HAlloc(BIF_P, 7);
BIF_RET(TUPLE6(hp,
make_small((uint)minor_global_gc),
make_small((uint)major_global_gc),
make_small(tmp_used_heap),
make_small(tmp_allocated_heap),
make_small(max_used_global_heap),
make_small(max_allocated_global_heap)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_incremental_gc_info_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#if !defined(BM_COUNTERS)
Uint minor_gc_cycles = 0;
Uint major_gc_cycles = 0;
Uint minor_gc_stages = 0;
Uint major_gc_stages = 0;
#endif
Eterm *hp;
hp = HAlloc(BIF_P, 5);
BIF_RET(TUPLE4(hp,
make_small(minor_gc_cycles),
make_small(major_gc_cycles),
make_small(minor_gc_stages),
make_small(major_gc_stages)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_gc_info_clear_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
#ifdef BM_COUNTERS
minor_gc = 0;
major_gc = 0;
#endif
#ifdef BM_HEAP_SIZES
max_used_heap = 0;
max_allocated_heap = 0;
max_used_global_heap = 0;
max_allocated_global_heap = 0;
#endif
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_pause_times_0(BIF_ALIST_0)
{
#ifdef BM_TIMERS
int i;
int total_time = 0, n = 0;
int left = 0, right = 0, mid = 0;
printf("Pause times in minor collection:\r\n");
for (i = 0; i < MAX_PAUSE_TIME; i++) {
if (pause_times[i] > 0) {
printf("%d: %ld\r\n", i, pause_times[i]);
total_time += pause_times[i] * i;
n += pause_times[i];
if (i > mid)
right += pause_times[i];
while (right > left) {
left += pause_times[mid++];
right -= pause_times[mid];
}
}
}
printf("Number of collections: %d\r\n", n);
printf("Total collection time: %d\r\n", total_time);
if (n > 0)
printf("Mean pause time: %d\r\n", total_time / n);
printf("Geometrical mean: %d\r\n", mid);
total_time = 0; n = 0;
left = 0; right = 0; mid = 0;
printf("Pause times in major collection:\r\n");
for (i = 0; i < MAX_PAUSE_TIME; i++) {
if (pause_times_old[i] > 0) {
printf("%d: %ld\r\n", i, pause_times_old[i]);
total_time += pause_times_old[i] * i;
n += pause_times_old[i];
}
}
printf("Number of collections: %d\r\n", n);
printf("Total collection time: %d\r\n", total_time);
if (n > 0)
printf("Mean pause time: %d\r\n", total_time / n);
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
/* XXX: these macros have free variables */
#ifdef BM_TIMERS
#define MAKE_TIME(_timer_) { \
BM_TIMER_T tmp = _timer_##_time / 1000000; \
milli = tmp % 1000; \
tmp /= 1000; \
sec = tmp % 60; \
min = tmp / 60; }
#define MAKE_MICRO_TIME(_timer_) { \
BM_TIMER_T tmp = _timer_##_time / 1000; \
micro = tmp % 1000; \
tmp /= 1000; \
milli = tmp % 1000; \
sec = tmp / 1000; }
#else
#define MAKE_TIME(_timer_)
#define MAKE_MICRO_TIME(_timer_)
#endif
BIF_RETTYPE hipe_bifs_system_timer_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
uint min = 0;
uint sec = 0;
uint milli = 0;
Eterm *hp;
hp = HAlloc(BIF_P, 4);
MAKE_TIME(system);
BIF_RET(TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli)));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_system_timer_clear_0(BIF_ALIST_0)
{
#ifdef BM_TIMERS
system_time = 0;
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_send_timer_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
uint min = 0;
uint sec = 0;
uint milli = 0;
Eterm *hp;
Eterm sendtime, copytime, sizetime;
hp = HAlloc(BIF_P, 4 * 4);
MAKE_TIME(send);
sendtime = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(copy);
copytime = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(size);
sizetime = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
BIF_RET(TUPLE3(hp, sendtime, copytime, sizetime));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_send_timer_clear_0(BIF_ALIST_0)
{
#ifdef BM_TIMERS
send_time = 0;
copy_time = 0;
size_time = 0;
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_gc_timer_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
Eterm *hp;
uint min = 0;
uint sec = 0;
uint milli = 0;
uint micro = 0;
Eterm minor, major, max_min, max_maj;
hp = HAlloc(BIF_P, 4 * 4 + 5);
MAKE_TIME(minor_gc);
minor = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(major_gc);
major = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_MICRO_TIME(max_minor);
max_min = TUPLE3(hp,
make_small(sec),
make_small(milli),
make_small(micro));
hp += 4;
MAKE_MICRO_TIME(max_major);
max_maj = TUPLE3(hp,
make_small(sec),
make_small(milli),
make_small(micro));
hp += 4;
BIF_RET(TUPLE4(hp, minor, major, max_min, max_maj));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_shared_gc_timer_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
Eterm *hp;
uint min = 0;
uint sec = 0;
uint milli = 0;
uint micro = 0;
Eterm minor, major, max_min, max_maj;
hp = HAlloc(BIF_P, 4 * 4 + 5);
MAKE_TIME(minor_global_gc);
minor = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(major_global_gc);
major = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_MICRO_TIME(max_global_minor);
max_min = TUPLE3(hp,
make_small(sec),
make_small(milli),
make_small(micro));
hp += 4;
MAKE_MICRO_TIME(max_global_major);
max_maj = TUPLE3(hp,
make_small(sec),
make_small(milli),
make_small(micro));
hp += 4;
BIF_RET(TUPLE4(hp, minor, major, max_min, max_maj));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_gc_timer_clear_0(BIF_ALIST_0)
{
#ifdef BM_TIMERS
minor_gc_time = 0;
major_gc_time = 0;
max_minor_time = 0;
max_major_time = 0;
minor_global_gc_time = 0;
major_global_gc_time = 0;
max_global_minor_time = 0;
max_global_major_time = 0;
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_misc_timer_0(BIF_ALIST_0)
{
#ifdef __BENCHMARK__
uint min = 0;
uint sec = 0;
uint milli = 0;
Eterm *hp;
Eterm misctime1, misctime2, misctime3;
hp = HAlloc(BIF_P, 4 * 4);
MAKE_TIME(misc0);
misctime1 = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(misc1);
misctime2 = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
MAKE_TIME(misc2);
misctime3 = TUPLE3(hp,
make_small(min),
make_small(sec),
make_small(milli));
hp += 4;
BIF_RET(TUPLE3(hp, misctime1, misctime2, misctime3));
#else
BIF_RET(am_false);
#endif
}
BIF_RETTYPE hipe_bifs_misc_timer_clear_0(BIF_ALIST_0)
{
#ifdef BM_TIMERS
misc0_time = 0;
misc1_time = 0;
misc2_time = 0;
BIF_RET(am_true);
#else
BIF_RET(am_false);
#endif
}
#undef MAKE_TIME
#undef MAKE_MICRO_TIME
/*
* HiPE hrvtime().
* These implementations are currently available:
* + The fallback, which is the same as {X,_} = runtime(statistics).
*/
static double fallback_get_hrvtime(void)
{
unsigned long ms_user;
elapsed_time_both(&ms_user, NULL, NULL, NULL);
return (double)ms_user;
}
/*
* Fallback, if nothing better exists.
* This is the same as {X,_} = statistics(runtime), which uses
* times(2) on Unix systems.
*/
#define hrvtime_is_started() 1
#define start_hrvtime() do{}while(0)
#define stop_hrvtime() do{}while(0)
#define get_hrvtime() fallback_get_hrvtime()
BIF_RETTYPE hipe_bifs_get_hrvtime_0(BIF_ALIST_0)
{
Eterm *hp;
Eterm res;
FloatDef f;
if (!hrvtime_is_started())
start_hrvtime();
f.fd = get_hrvtime();
hp = HAlloc(BIF_P, FLOAT_SIZE_OBJECT);
res = make_float(hp);
PUT_DOUBLE(f, hp);
BIF_RET(res);
}
BIF_RETTYPE hipe_bifs_stop_hrvtime_0(BIF_ALIST_0)
{
stop_hrvtime();
BIF_RET(am_true);
}
