@@ -16,12 +16,12 @@ extern "C" {
1616// This struct allows adding some state that is only visible to the EE onto the standard gc_alloc_context
1717struct ee_alloc_context
1818{
19- // Any allocation that would overlap combined_limit needs to be handled by the allocation slow path.
20- // combined_limit is the minimum of:
19+ // Any allocation that would overlap m_CombinedLimit needs to be handled by the allocation slow path.
20+ // m_CombinedLimit is the minimum of:
2121 // - gc_alloc_context.alloc_limit (the end of the current AC)
2222 // - the sampling_limit
2323 //
24- // In the simple case that randomized sampling is disabled, combined_limit is always equal to alloc_limit.
24+ // In the simple case that randomized sampling is disabled, m_CombinedLimit is always equal to alloc_limit.
2525 //
2626 // There are two different useful interpretations for the sampling_limit. One is to treat the sampling_limit
2727 // as an address and when we allocate an object that overlaps that address we should emit a sampling event.
@@ -32,46 +32,46 @@ struct ee_alloc_context
3232 // flexible to handle those cases.
3333 //
3434 // The sampling limit isn't stored in any separate field explicitly, instead it is implied:
35- // - if combined_limit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
35+ // - if m_CombinedLimit == alloc_limit there is no sampled byte in the AC. In the budget interpretation
3636 // we can allocate (alloc_limit - alloc_ptr) unsampled bytes. We'll need a new random number after
3737 // that to determine whether future allocated bytes should be sampled.
3838 // This occurs either because the sampling feature is disabled, or because the randomized selection
3939 // of sampled bytes didn't select a byte in this AC.
40- // - if combined_limit < alloc_limit there is a sample limit in the AC. sample_limit = combined_limit .
41- uint8_t * combined_limit ;
42- gc_alloc_context gc_allocation_context ;
40+ // - if m_CombinedLimit < alloc_limit there is a sample limit in the AC. sample_limit = m_CombinedLimit .
41+ uint8_t * m_CombinedLimit ;
42+ gc_alloc_context m_GCAllocContext ;
4343
4444 void init ()
4545 {
4646 LIMITED_METHOD_CONTRACT;
47- combined_limit = 0 ;
48- gc_allocation_context .init ();
47+ m_CombinedLimit = 0 ;
48+ m_GCAllocContext .init ();
4949 }
5050
5151 uint8_t * getCombinedLimit ()
5252 {
5353 LIMITED_METHOD_CONTRACT;
54- return combined_limit ;
54+ return m_CombinedLimit ;
5555 }
5656
5757 static size_t getAllocPtrFieldOffset ()
5858 {
5959 LIMITED_METHOD_CONTRACT;
60- return offsetof (ee_alloc_context, gc_allocation_context ) + offsetof (gc_alloc_context, alloc_ptr);
60+ return offsetof (ee_alloc_context, m_GCAllocContext ) + offsetof (gc_alloc_context, alloc_ptr);
6161 }
6262
6363 static size_t getCombinedLimitFieldOffset ()
6464 {
6565 LIMITED_METHOD_CONTRACT;
66- return offsetof (ee_alloc_context, combined_limit );
66+ return offsetof (ee_alloc_context, m_CombinedLimit );
6767 }
6868
69- // Regenerate the randomized sampling limit and update the combined_limit field.
69+ // Regenerate the randomized sampling limit and update the m_CombinedLimit field.
7070 inline void UpdateCombinedLimit ()
7171 {
7272 // The randomized sampling feature is being submitted in stages. At this point the sampling is never
73- // activated so combined_limit is always equal to alloc_limit.
74- combined_limit = gc_allocation_context .alloc_limit ;
73+ // activated so m_CombinedLimit is always equal to alloc_limit.
74+ m_CombinedLimit = m_GCAllocContext .alloc_limit ;
7575 }
7676};
7777
0 commit comments