mirror of
https://github.com/moses-smt/mosesdecoder.git
synced 2024-12-28 06:22:14 +03:00
146 lines
3.9 KiB
C
146 lines
3.9 KiB
C
/*
|
|
* Copyright 2005. Rene Rivera
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE_1_0.txt or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
|
|
#include "jam.h"
|
|
#include "debug.h"
|
|
|
|
#include "hash.h"
|
|
|
|
|
|
static profile_frame * profile_stack = 0;
|
|
static struct hash * profile_hash = 0;
|
|
static profile_info profile_other = { 0 };
|
|
static profile_info profile_total = { 0 };
|
|
|
|
|
|
profile_frame * profile_init( OBJECT * rulename, profile_frame * frame )
|
|
{
|
|
if ( DEBUG_PROFILE ) profile_enter( rulename, frame );
|
|
return frame;
|
|
}
|
|
|
|
|
|
void profile_enter( OBJECT * rulename, profile_frame * frame )
|
|
{
|
|
if ( DEBUG_PROFILE )
|
|
{
|
|
clock_t start = clock();
|
|
profile_info * p;
|
|
|
|
if ( !profile_hash && rulename )
|
|
profile_hash = hashinit( sizeof( profile_info ), "profile" );
|
|
|
|
if ( rulename )
|
|
{
|
|
int found;
|
|
p = (profile_info *)hash_insert( profile_hash, rulename, &found );
|
|
if ( !found )
|
|
{
|
|
p->name = rulename;
|
|
p->cumulative = 0;
|
|
p->net = 0;
|
|
p->num_entries = 0;
|
|
p->stack_count = 0;
|
|
p->memory = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p = &profile_other;
|
|
}
|
|
|
|
++p->num_entries;
|
|
++p->stack_count;
|
|
|
|
frame->info = p;
|
|
|
|
frame->caller = profile_stack;
|
|
profile_stack = frame;
|
|
|
|
frame->entry_time = clock();
|
|
frame->overhead = 0;
|
|
frame->subrules = 0;
|
|
|
|
/* caller pays for the time it takes to play with the hash table */
|
|
if ( frame->caller )
|
|
frame->caller->overhead += frame->entry_time - start;
|
|
}
|
|
}
|
|
|
|
|
|
void profile_memory( long mem )
|
|
{
|
|
if ( DEBUG_PROFILE )
|
|
if ( profile_stack && profile_stack->info )
|
|
profile_stack->info->memory += mem;
|
|
}
|
|
|
|
|
|
void profile_exit( profile_frame * frame )
|
|
{
|
|
if ( DEBUG_PROFILE )
|
|
{
|
|
/* Cumulative time for this call. */
|
|
clock_t const t = clock() - frame->entry_time - frame->overhead;
|
|
/* If this rule is already present on the stack, do not add the time for
|
|
* this instance.
|
|
*/
|
|
if ( frame->info->stack_count == 1 )
|
|
frame->info->cumulative += t;
|
|
/* Net time does not depend on presense of the same rule in call stack.
|
|
*/
|
|
frame->info->net += t - frame->subrules;
|
|
|
|
if ( frame->caller )
|
|
{
|
|
/* Caller's cumulative time must account for this overhead. */
|
|
frame->caller->overhead += frame->overhead;
|
|
frame->caller->subrules += t;
|
|
}
|
|
/* Pop this stack frame. */
|
|
--frame->info->stack_count;
|
|
profile_stack = frame->caller;
|
|
}
|
|
}
|
|
|
|
|
|
static void dump_profile_entry( void * p_, void * ignored )
|
|
{
|
|
profile_info * p = (profile_info *)p_;
|
|
unsigned long mem_each = ( p->memory / ( p->num_entries ? p->num_entries : 1
|
|
) );
|
|
double cumulative = p->cumulative;
|
|
double net = p->net;
|
|
double q = p->net;
|
|
q /= ( p->num_entries ? p->num_entries : 1 );
|
|
cumulative /= CLOCKS_PER_SEC;
|
|
net /= CLOCKS_PER_SEC;
|
|
q /= CLOCKS_PER_SEC;
|
|
if ( !ignored )
|
|
{
|
|
profile_total.cumulative += p->net;
|
|
profile_total.memory += p->memory;
|
|
}
|
|
printf( "%10ld %12.6f %12.6f %12.8f %10ld %10ld %s\n", p->num_entries,
|
|
cumulative, net, q, p->memory, mem_each, object_str( p->name ) );
|
|
}
|
|
|
|
|
|
void profile_dump()
|
|
{
|
|
if ( profile_hash )
|
|
{
|
|
printf( "%10s %12s %12s %12s %10s %10s %s\n", "--count--", "--gross--",
|
|
"--net--", "--each--", "--mem--", "--each--", "--name--" );
|
|
hashenumerate( profile_hash, dump_profile_entry, 0 );
|
|
profile_other.name = constant_other;
|
|
dump_profile_entry( &profile_other, 0 );
|
|
profile_total.name = constant_total;
|
|
dump_profile_entry( &profile_total, (void *)1 );
|
|
}
|
|
}
|