15004044467

Committed 13 May 2025 06:29PM UTC coverage: 55.958% (+0.03%) from 55.933%

Build # 15004044467

Build Type

Pull #1877

github

Committed by

web-flow

Commit Message

Merge d70b5de90 into ff58ed109

Pull Request Pull Request #1877: Resolved comments being parsed inside strings

Run Details

12332 of 22038 relevant lines covered (55.96%)

264644.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.24

/trick_source/sim_services/MemoryManager/MemoryManager.cpp

#include <dlfcn.h>
#include <stdlib.h>
#include "trick/MemoryManager.hh"
#include "trick/ClassicCheckPointAgent.hh"
// Global pointer to the (singleton) MemoryManager for the C language interface.
Trick::MemoryManager * trick_MM = NULL;

// CLASS VARIABLE INITIALIZATION
int Trick::MemoryManager::instance_count = 0;
bool Trick::MemoryManager::restore_stls_default = true;

// CONSTRUCTOR
Trick::MemoryManager::MemoryManager()
{


    // The MemoryManager is a singleton. That is only one instance of it is allowed.
    if (instance_count != 0) {
        throw std::logic_error("Only one instance of the Memory Manager is allowed.");
    }
    instance_count ++;

    debug_level = 0;
    hexfloat_checkpoint = 0;
    reduced_checkpoint  = 1;
    resetting_memory = false;
    expanded_arrays  = 0;
    // start counter at 100mil.  This (hopefully) ensures all alloc'ed ids are after external variables.
    alloc_info_map_counter = 100000000 ;
    // start counter at 0.  This forces extern vars to appear in front of actual allocations in checkpoint.
    extern_alloc_info_map_counter = 0 ;
    pthread_mutex_init(&mm_mutex, NULL);

    defaultCheckPointAgent = new ClassicCheckPointAgent( this);
    defaultCheckPointAgent->set_reduced_checkpoint( reduced_checkpoint);
    defaultCheckPointAgent->set_hexfloat_checkpoint( hexfloat_checkpoint);
    defaultCheckPointAgent->set_debug_level( debug_level);

    currentCheckPointAgent = defaultCheckPointAgent;

    dlhandles.push_back(dlopen( NULL, RTLD_LAZY)) ;

    local_anon_var_prefix = "trick_anon_local_";
    extern_anon_var_prefix = "trick_anon_extern_";

    primitive_types.insert(std::string("char")) ;
    primitive_types.insert(std::string("unsigned char")) ;
    primitive_types.insert(std::string("short")) ;
    primitive_types.insert(std::string("unsigned short")) ;
    primitive_types.insert(std::string("int")) ;
    primitive_types.insert(std::string("unsigned int")) ;
    primitive_types.insert(std::string("long")) ;
    primitive_types.insert(std::string("unsigned long")) ;
    primitive_types.insert(std::string("long long")) ;
    primitive_types.insert(std::string("unsigned long long")) ;
    primitive_types.insert(std::string("double")) ;
    primitive_types.insert(std::string("float")) ;
    primitive_types.insert(std::string("bool")) ;
    // add stdint.h types
    primitive_types.insert(std::string("int8_t")) ;
    primitive_types.insert(std::string("uint8_t")) ;
    primitive_types.insert(std::string("int16_t")) ;
    primitive_types.insert(std::string("uint16_t")) ;
    primitive_types.insert(std::string("int32_t")) ;
    primitive_types.insert(std::string("uint32_t")) ;
    primitive_types.insert(std::string("int64_t")) ;
    primitive_types.insert(std::string("uint64_t")) ;

    trick_MM = this;
    return ;
}

Trick::MemoryManager::~MemoryManager() {

    ALLOC_INFO_MAP::iterator ait ;

    if (instance_count > 0) {
        instance_count --;
    }

    delete defaultCheckPointAgent ;

    for ( ait = alloc_info_map.begin() ; ait != alloc_info_map.end() ; ++ait ) {
        ALLOC_INFO * ai_ptr = (*ait).second ;
        if (ai_ptr->stcl == TRICK_LOCAL) {
            if ( ai_ptr->alloc_type == TRICK_ALLOC_MALLOC ) {
                free((char *)ai_ptr->start - ai_ptr->sentinel_bytes) ;
            } else if ( ai_ptr->alloc_type == TRICK_ALLOC_NEW ) {
                io_src_delete_class( ai_ptr );
            }
        }
        if (ai_ptr->name) { free(ai_ptr->name); }
        if (ai_ptr->user_type_name) { free(ai_ptr->user_type_name); }
        free(ai_ptr) ;
    }
    alloc_info_map.clear() ;
}

#include <sstream>
void Trick::MemoryManager::emitMessage( std::string message) {
    std::cerr << "MemoryManager:" << message << std::endl;
    std::cerr.flush();
}

void Trick::MemoryManager::emitError( std::string message) {
    std::stringstream ss;
    ss << "ERROR:" << message << std::endl;
    emitMessage( ss.str() );
}

void Trick::MemoryManager::emitWarning( std::string message) {
    std::stringstream ss;
    ss << "WARNING:" << message << std::endl;
    emitMessage( ss.str() );
}


1	#include <dlfcn.h>
2	#include <stdlib.h>
3	#include "trick/MemoryManager.hh"
4	#include "trick/ClassicCheckPointAgent.hh"
5	// Global pointer to the (singleton) MemoryManager for the C language interface.
6	Trick::MemoryManager * trick_MM = NULL;
7
8	// CLASS VARIABLE INITIALIZATION
9	int Trick::MemoryManager::instance_count = 0;
10	bool Trick::MemoryManager::restore_stls_default = true;
11
12	// CONSTRUCTOR
13	Trick::MemoryManager::MemoryManager()	636✔
14	{
15
16
17	// The MemoryManager is a singleton. That is only one instance of it is allowed.
18	if (instance_count != 0) {	627✔
19	throw std::logic_error("Only one instance of the Memory Manager is allowed.");	1✔
20	}
21	instance_count ++;	626✔
22
23	debug_level = 0;	626✔
24	hexfloat_checkpoint = 0;	626✔
25	reduced_checkpoint = 1;	626✔
26	resetting_memory = false;	626✔
27	expanded_arrays = 0;	626✔
28	// start counter at 100mil. This (hopefully) ensures all alloc'ed ids are after external variables.
29	alloc_info_map_counter = 100000000 ;	626✔
30	// start counter at 0. This forces extern vars to appear in front of actual allocations in checkpoint.
31	extern_alloc_info_map_counter = 0 ;	626✔
32	pthread_mutex_init(&mm_mutex, NULL);	626✔
33
34	defaultCheckPointAgent = new ClassicCheckPointAgent( this);	626✔
35	defaultCheckPointAgent->set_reduced_checkpoint( reduced_checkpoint);	626✔
36	defaultCheckPointAgent->set_hexfloat_checkpoint( hexfloat_checkpoint);	626✔
37	defaultCheckPointAgent->set_debug_level( debug_level);	626✔
38
39	currentCheckPointAgent = defaultCheckPointAgent;	626✔
40
41	dlhandles.push_back(dlopen( NULL, RTLD_LAZY)) ;	626✔
42
43	local_anon_var_prefix = "trick_anon_local_";	626✔
44	extern_anon_var_prefix = "trick_anon_extern_";	626✔
45
46	primitive_types.insert(std::string("char")) ;	626✔
47	primitive_types.insert(std::string("unsigned char")) ;	626✔
48	primitive_types.insert(std::string("short")) ;	626✔
49	primitive_types.insert(std::string("unsigned short")) ;	626✔
50	primitive_types.insert(std::string("int")) ;	626✔
51	primitive_types.insert(std::string("unsigned int")) ;	626✔
52	primitive_types.insert(std::string("long")) ;	626✔
53	primitive_types.insert(std::string("unsigned long")) ;	626✔
54	primitive_types.insert(std::string("long long")) ;	626✔
55	primitive_types.insert(std::string("unsigned long long")) ;	626✔
56	primitive_types.insert(std::string("double")) ;	626✔
57	primitive_types.insert(std::string("float")) ;	626✔
58	primitive_types.insert(std::string("bool")) ;	626✔
59	// add stdint.h types
60	primitive_types.insert(std::string("int8_t")) ;	626✔
61	primitive_types.insert(std::string("uint8_t")) ;	626✔
62	primitive_types.insert(std::string("int16_t")) ;	626✔
63	primitive_types.insert(std::string("uint16_t")) ;	626✔
64	primitive_types.insert(std::string("int32_t")) ;	626✔
65	primitive_types.insert(std::string("uint32_t")) ;	626✔
66	primitive_types.insert(std::string("int64_t")) ;	626✔
67	primitive_types.insert(std::string("uint64_t")) ;	626✔
68
69	trick_MM = this;	626✔
70	return ;	626✔
71	}
72
73	Trick::MemoryManager::~MemoryManager() {	625✔
74
75	ALLOC_INFO_MAP::iterator ait ;	625✔
76
77	if (instance_count > 0) {	625✔
78	instance_count --;	625✔
79	}
80
81	delete defaultCheckPointAgent ;	625✔
82
83	for ( ait = alloc_info_map.begin() ; ait != alloc_info_map.end() ; ++ait ) {	7,750✔
84	ALLOC_INFO * ai_ptr = (*ait).second ;	7,125✔
85	if (ai_ptr->stcl == TRICK_LOCAL) {	7,125✔
86	if ( ai_ptr->alloc_type == TRICK_ALLOC_MALLOC ) {	2,357✔
87	free((char *)ai_ptr->start - ai_ptr->sentinel_bytes) ;	1,701✔
88	} else if ( ai_ptr->alloc_type == TRICK_ALLOC_NEW ) {	656✔
89	io_src_delete_class( ai_ptr );	33✔
90	}
91	}
92	if (ai_ptr->name) { free(ai_ptr->name); }	7,125✔
93	if (ai_ptr->user_type_name) { free(ai_ptr->user_type_name); }	7,125✔
94	free(ai_ptr) ;	7,125✔
95	}
96	alloc_info_map.clear() ;	625✔
97	}	625✔
98
99	#include <sstream>
100	void Trick::MemoryManager::emitMessage( std::string message) {	8✔
101	std::cerr << "MemoryManager:" << message << std::endl;	8✔
102	std::cerr.flush();	8✔
103	}	8✔
104
105	void Trick::MemoryManager::emitError( std::string message) {	8✔
106	std::stringstream ss;	8✔
107	ss << "ERROR:" << message << std::endl;	8✔
108	emitMessage( ss.str() );	8✔
109	}	8✔
110
111	void Trick::MemoryManager::emitWarning( std::string message) {	×
112	std::stringstream ss;	×
113	ss << "WARNING:" << message << std::endl;	×
114	emitMessage( ss.str() );	×
115	}	×
116

nasa / trick / 15004044467

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous