Sierra Toolkit  Version of the Day
MemoryUsage.cpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2010 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
9 
10 #include <stk_mesh/base/MemoryUsage.hpp>
11 #include <stk_mesh/base/GetEntities.hpp>
12 
13 #include <iostream>
14 
15 namespace stk_classic {
16 namespace mesh {
17 
18 void compute_memory_usage(const BulkData& bulk, MemoryUsage& mem_usage)
19 {
20  mem_usage.entity_rank_names = bulk.mesh_meta_data().entity_rank_names();
21 
22  const FieldVector& fields = bulk.mesh_meta_data().get_fields();
23  mem_usage.num_fields = fields.size();
24  mem_usage.field_bytes = fields.size()*sizeof(FieldBase);
25  for(size_t i=0; i<fields.size(); ++i) {
26  mem_usage.field_bytes += fields[i]->name().length();
27  mem_usage.field_bytes += sizeof(FieldRestriction)*fields[i]->restrictions().size();
28  }
29 
30  const PartVector& parts = bulk.mesh_meta_data().get_parts();
31  mem_usage.num_parts = parts.size();
32  mem_usage.part_bytes = parts.size()*sizeof(Part);
33  for(size_t i=0; i<parts.size(); ++i) {
34  mem_usage.part_bytes += parts[i]->name().length();
35  mem_usage.part_bytes += sizeof(Part*) * parts[i]->supersets().size();
36  mem_usage.part_bytes += sizeof(Part*) * parts[i]->subsets().size();
37  mem_usage.part_bytes += sizeof(Part*) * parts[i]->intersection_of().size();
38  mem_usage.part_bytes += sizeof(PartRelation) * parts[i]->relations().size();
39  }
40 
41  size_t total_bytes = mem_usage.field_bytes + mem_usage.part_bytes;
42 
43  mem_usage.entity_counts.clear();
44  mem_usage.downward_relation_counts.clear();
45  mem_usage.upward_relation_counts.clear();
46  mem_usage.bucket_counts.clear();
47  mem_usage.bucket_bytes.clear();
48 
49  Selector all = bulk.mesh_meta_data().universal_part();
50  count_entities(all, bulk, mem_usage.entity_counts);
51 
52  size_t nranks = mem_usage.entity_counts.size();
53  mem_usage.downward_relation_counts.resize(nranks, 0);
54  mem_usage.upward_relation_counts.resize(nranks, 0);
55  mem_usage.bucket_counts.resize(nranks, 0);
56  mem_usage.bucket_bytes.resize(nranks, 0);
57 
58  std::vector<Entity*> entities;
59  for(size_t i=0; i<nranks; ++i) {
60  EntityRank rank = i;
61  total_bytes += mem_usage.entity_counts[rank]*sizeof(Entity);
62 
63  get_entities(bulk, rank, entities);
64 
65  for(size_t n=0; n<entities.size(); ++n) {
66  Entity& entity = *entities[n];
67  for(EntityRank r=0; r<i; ++r) {
68  unsigned num_rels = entity.relations(r).size();
69  mem_usage.downward_relation_counts[r] += num_rels;
70  total_bytes += num_rels*sizeof(Relation);
71  }
72  for(EntityRank r=i+1; r<nranks; ++r) {
73  unsigned num_rels = entity.relations(r).size();
74  mem_usage.upward_relation_counts[r] += num_rels;
75  total_bytes += num_rels*sizeof(Relation);
76  }
77  }
78 
79  const std::vector<Bucket*>& buckets = bulk.buckets(rank);
80  mem_usage.bucket_counts[rank] = buckets.size();
81  for(size_t b=0; b<buckets.size(); ++b) {
82  Bucket& bucket = *buckets[b];
83  mem_usage.bucket_bytes[rank] += bucket.allocation_size();
84  total_bytes += bucket.allocation_size();
85  }
86  }
87 
88  mem_usage.total_bytes = total_bytes;
89 }
90 
91 void print_memory_usage(const MemoryUsage& mem_usage, std::ostream& os)
92 {
93  os << "----- stk_mesh Memory Usage: ------"<<std::endl;
94  os << "Fields:"<<std::endl;
95  os << " "<<mem_usage.num_fields<<" fields, "<<mem_usage.field_bytes<<" bytes"<<std::endl;
96  os << "Parts:"<<std::endl;
97  os << " "<<mem_usage.num_parts<<" parts, "<<mem_usage.part_bytes<<" bytes"<<std::endl;
98  os << "Entities:"<<std::endl;
99  for(size_t i=0; i<mem_usage.entity_counts.size(); ++i) {
100  int n = mem_usage.entity_counts[i];
101  unsigned bytes = n*sizeof(Entity);
102  if (mem_usage.entity_rank_names.size() > i)
103  os << " "<<mem_usage.entity_rank_names[i]<<": ";
104  else
105  os << " Rank "<<i<<": ";
106  os << n << " entities, "<< bytes<<" bytes"<<std::endl;
107  }
108  os << "Downward Relations:"<<std::endl;
109  for(size_t i=0; i<mem_usage.downward_relation_counts.size(); ++i) {
110  int n = mem_usage.downward_relation_counts[i];
111  unsigned bytes = n*sizeof(Relation);
112  if (mem_usage.entity_rank_names.size() > i)
113  os << " "<<mem_usage.entity_rank_names[i]<<": ";
114  else
115  os << " Rank "<<i<<": ";
116  os << n << " relations, "<< bytes<<" bytes"<<std::endl;
117  }
118  os << "Upward Relations:"<<std::endl;
119  for(size_t i=0; i<mem_usage.upward_relation_counts.size(); ++i) {
120  int n = mem_usage.upward_relation_counts[i];
121  unsigned bytes = n*sizeof(Relation);
122  if (mem_usage.entity_rank_names.size() > i)
123  os << " "<<mem_usage.entity_rank_names[i]<<": ";
124  else
125  os << " Rank "<<i<<": ";
126  os << n << " relations, "<< bytes<<" bytes"<<std::endl;
127  }
128  os << "Buckets:"<<std::endl;
129  for(size_t i=0; i<mem_usage.bucket_counts.size(); ++i) {
130  int n = mem_usage.bucket_counts[i];
131  unsigned bytes = mem_usage.bucket_bytes[i];
132  if (mem_usage.entity_rank_names.size() > i)
133  os << " "<<mem_usage.entity_rank_names[i]<<": ";
134  else
135  os << " Rank "<<i<<": ";
136  os << n << " buckets, "<< bytes<<" bytes"<<std::endl;
137  }
138  os << "Total bytes: "<<mem_usage.total_bytes<<" ("<<((double)mem_usage.total_bytes)/(1024*1024)<<"MB)"<<std::endl;
139 }
140 
141 }//namespace mesh
142 }//namespace stk_classic
143 
144 
PairIterRelation relations() const
All Entity relations for which this entity is a member. The relations are ordered from lowest entity-...
Definition: Entity.hpp:161
void get_entities(const BulkData &mesh, EntityRank entity_rank, std::vector< Entity *> &entities)
Get all entities of the specified type, sorted by ID.
Definition: GetEntities.cpp:25
Sierra Toolkit.
void count_entities(const Selector &selector, const BulkData &mesh, std::vector< EntityRank > &count)
Local count selected entities of each type.
std::vector< Part *> PartVector
Collections of parts are frequently maintained as a vector of Part pointers.
Definition: Types.hpp:31