void
sc_package_rc_count_add (int package_id, int toadd)
{
int *pcount;
#ifdef SC_ENABLE_DEBUG
int newvalue;
#endif
if (package_id == -1) {
pcount = &default_rc_active;
}
else {
SC_ASSERT (sc_package_is_registered (package_id));
pcount = &sc_packages[package_id].rc_active;
}
sc_package_lock (package_id);
#ifdef SC_ENABLE_DEBUG
newvalue =
#endif
*pcount += toadd;
sc_package_unlock (package_id);
SC_ASSERT (newvalue >= 0);
}
void
sc_memory_check (int package)
{
sc_package_t *p;
if (package == -1) {
SC_CHECK_ABORT (default_rc_active == 0, "Leftover references (default)");
if (default_abort_mismatch) {
SC_CHECK_ABORT (default_malloc_count == default_free_count,
"Memory balance (default)");
}
else if (default_malloc_count != default_free_count) {
SC_GLOBAL_LERROR ("Memory balance (default)\n");
}
}
else {
SC_ASSERT (sc_package_is_registered (package));
p = sc_packages + package;
SC_CHECK_ABORTF (p->rc_active == 0, "Leftover references (%s)", p->name);
if (p->abort_mismatch) {
SC_CHECK_ABORTF (p->malloc_count == p->free_count,
"Memory balance (%s)", p->name);
}
else if (p->malloc_count != p->free_count) {
SC_GLOBAL_LERRORF ("Memory balance (%s)\n", p->name);
}
}
}
void
sc_package_unregister (int package_id)
{
#ifdef SC_ENABLE_PTHREAD
int i;
#endif
sc_package_t *p;
SC_CHECK_ABORT (sc_package_is_registered (package_id),
"Package not registered");
sc_memory_check (package_id);
p = sc_packages + package_id;
p->is_registered = 0;
p->log_handler = NULL;
p->log_threshold = SC_LP_DEFAULT;
p->malloc_count = p->free_count = 0;
p->rc_active = 0;
#ifdef SC_ENABLE_PTHREAD
i = pthread_mutex_destroy (&p->mutex);
SC_CHECK_ABORTF (i == 0, "Mutex destroy failed for package %s", p->name);
#endif
p->name = p->full = NULL;
--sc_num_packages;
}
static int *
sc_free_count (int package)
{
if (package == -1)
return &default_free_count;
SC_ASSERT (sc_package_is_registered (package));
return &sc_packages[package].free_count;
}
void
sc_package_set_abort_alloc_mismatch (int package_id, int set_abort)
{
if (package_id == -1) {
default_abort_mismatch = set_abort;
}
else {
sc_package_t *p;
SC_ASSERT (sc_package_is_registered (package_id));
p = sc_packages + package_id;
p->abort_mismatch = set_abort;
}
}
int
sc_memory_status (int package)
{
sc_package_t *p;
if (package == -1) {
return (default_malloc_count - default_free_count);
}
else {
SC_ASSERT (sc_package_is_registered (package));
p = sc_packages + package;
return (p->malloc_count - p->free_count);
}
}
static inline pthread_mutex_t *
sc_package_mutex (int package)
{
if (package == -1) {
return &sc_default_mutex;
}
else {
#ifdef SC_ENABLE_DEBUG
sc_check_abort_thread (sc_package_is_registered (package),
package, "sc_package_mutex");
#endif
return &sc_packages[package].mutex;
}
}
void
sc_package_set_verbosity (int package_id, int log_priority)
{
sc_package_t *p;
SC_CHECK_ABORT (sc_package_is_registered (package_id),
"Package id is not registered");
SC_CHECK_ABORT (log_priority == SC_LP_DEFAULT ||
(log_priority >= SC_LP_ALWAYS &&
log_priority <= SC_LP_SILENT),
"Invalid package log threshold");
p = sc_packages + package_id;
p->log_threshold = log_priority;
}
void
sc_memory_check (int package)
{
sc_package_t *p;
if (package == -1)
SC_CHECK_ABORT (default_malloc_count == default_free_count,
"Memory balance (default)");
else {
SC_ASSERT (sc_package_is_registered (package));
p = sc_packages + package;
SC_CHECK_ABORTF (p->malloc_count == p->free_count,
"Memory balance (%s)", p->name);
}
}
void
sc_log (const char *filename, int lineno,
int package, int category, int priority, const char *msg)
{
int log_threshold;
sc_log_handler_t log_handler;
sc_package_t *p;
if (package != -1 && !sc_package_is_registered (package)) {
package = -1;
}
if (package == -1) {
p = NULL;
log_threshold = sc_default_log_threshold;
log_handler = sc_default_log_handler;
}
else {
p = sc_packages + package;
log_threshold =
(p->log_threshold ==
SC_LP_DEFAULT) ? sc_default_log_threshold : p->log_threshold;
log_handler =
(p->log_handler == NULL) ? sc_default_log_handler : p->log_handler;
}
if (!(category == SC_LC_NORMAL || category == SC_LC_GLOBAL))
return;
if (!(priority > SC_LP_ALWAYS && priority < SC_LP_SILENT))
return;
if (category == SC_LC_GLOBAL && sc_identifier > 0)
return;
#ifdef SC_ENABLE_PTHREAD
sc_package_lock (package);
#endif
if (sc_trace_file != NULL && priority >= sc_trace_prio)
log_handler (sc_trace_file, filename, lineno,
package, category, priority, msg);
if (priority >= log_threshold)
log_handler (sc_log_stream != NULL ? sc_log_stream : stdout,
filename, lineno, package, category, priority, msg);
#ifdef SC_ENABLE_PTHREAD
sc_package_unlock (package);
#endif
}
void
sc_package_unregister (int package_id)
{
sc_package_t *p;
SC_CHECK_ABORT (sc_package_is_registered (package_id),
"Package not registered");
sc_memory_check (package_id);
p = sc_packages + package_id;
p->is_registered = 0;
p->log_handler = NULL;
p->log_threshold = SC_LP_DEFAULT;
p->malloc_count = p->free_count = 0;
p->name = p->full = NULL;
--sc_num_packages;
}
static void
sc_log_handler (FILE * log_stream, const char *filename, int lineno,
int package, int category, int priority, const char *msg)
{
int wp = 0, wi = 0;
int lindent = 0;
if (package != -1) {
if (!sc_package_is_registered (package))
package = -1;
else {
wp = 1;
lindent = sc_packages[package].log_indent;
}
}
wi = (category == SC_LC_NORMAL && sc_identifier >= 0);
if (wp || wi) {
fputc ('[', log_stream);
if (wp)
fprintf (log_stream, "%s", sc_packages[package].name);
if (wp && wi)
fputc (' ', log_stream);
if (wi)
fprintf (log_stream, "%d", sc_identifier);
fprintf (log_stream, "] %*s", lindent, "");
}
if (priority == SC_LP_TRACE) {
char bn[BUFSIZ], *bp;
snprintf (bn, BUFSIZ, "%s", filename);
bp = basename (bn);
fprintf (log_stream, "%s:%d ", bp, lineno);
}
fputs (msg, log_stream);
fflush (log_stream);
}
