@@ -30,13 +30,11 @@ const minPhysPageSize = 4096
3030//go:notinheap
3131type mheap struct {
3232 lock mutex
33- free [_MaxMHeapList ]mSpanList // free lists of given length up to _MaxMHeapList
34- freelarge mTreap // free treap of length >= _MaxMHeapList
35- busy [_MaxMHeapList ]mSpanList // busy lists of large spans of given length
36- busylarge mSpanList // busy lists of large spans length >= _MaxMHeapList
37- sweepgen uint32 // sweep generation, see comment in mspan
38- sweepdone uint32 // all spans are swept
39- sweepers uint32 // number of active sweepone calls
33+ free mTreap // free treap of spans
34+ busy mSpanList // busy list of spans
35+ sweepgen uint32 // sweep generation, see comment in mspan
36+ sweepdone uint32 // all spans are swept
37+ sweepers uint32 // number of active sweepone calls
4038
4139 // allspans is a slice of all mspans ever created. Each mspan
4240 // appears exactly once.
@@ -599,12 +597,7 @@ func (h *mheap) init() {
599597 h .spanalloc .zero = false
600598
601599 // h->mapcache needs no init
602- for i := range h .free {
603- h .free [i ].init ()
604- h .busy [i ].init ()
605- }
606-
607- h .busylarge .init ()
600+ h .busy .init ()
608601 for i := range h .central {
609602 h .central [i ].mcentral .init (spanClass (i ))
610603 }
@@ -647,30 +640,12 @@ retry:
647640// Sweeps and reclaims at least npage pages into heap.
648641// Called before allocating npage pages.
649642func (h * mheap ) reclaim (npage uintptr ) {
650- // First try to sweep busy spans with large objects of size >= npage,
651- // this has good chances of reclaiming the necessary space.
652- for i := int (npage ); i < len (h .busy ); i ++ {
653- if h .reclaimList (& h .busy [i ], npage ) != 0 {
654- return // Bingo!
655- }
656- }
657-
658- // Then -- even larger objects.
659- if h .reclaimList (& h .busylarge , npage ) != 0 {
643+ if h .reclaimList (& h .busy , npage ) != 0 {
660644 return // Bingo!
661645 }
662646
663- // Now try smaller objects.
664- // One such object is not enough, so we need to reclaim several of them.
665- reclaimed := uintptr (0 )
666- for i := 0 ; i < int (npage ) && i < len (h .busy ); i ++ {
667- reclaimed += h .reclaimList (& h .busy [i ], npage - reclaimed )
668- if reclaimed >= npage {
669- return
670- }
671- }
672-
673647 // Now sweep everything that is not yet swept.
648+ var reclaimed uintptr
674649 unlock (& h .lock )
675650 for {
676651 n := sweepone ()
@@ -752,11 +727,7 @@ func (h *mheap) alloc_m(npage uintptr, spanclass spanClass, large bool) *mspan {
752727 mheap_ .nlargealloc ++
753728 atomic .Xadd64 (& memstats .heap_live , int64 (npage << _PageShift ))
754729 // Swept spans are at the end of lists.
755- if s .npages < uintptr (len (h .busy )) {
756- h .busy [s .npages ].insertBack (s )
757- } else {
758- h .busylarge .insertBack (s )
759- }
730+ h .busy .insertBack (s )
760731 }
761732 }
762733 // heap_scan and heap_live were updated.
@@ -867,31 +838,20 @@ func (h *mheap) setSpans(base, npage uintptr, s *mspan) {
867838// The returned span has been removed from the
868839// free list, but its state is still mSpanFree.
869840func (h * mheap ) allocSpanLocked (npage uintptr , stat * uint64 ) * mspan {
870- var list * mSpanList
871841 var s * mspan
872842
873- // Try in fixed-size lists up to max.
874- for i := int (npage ); i < len (h .free ); i ++ {
875- list = & h .free [i ]
876- if ! list .isEmpty () {
877- s = list .first
878- list .remove (s )
879- goto HaveSpan
880- }
881- }
882- // Best fit in list of large spans.
883- s = h .allocLarge (npage ) // allocLarge removed s from h.freelarge for us
843+ // Best fit in the treap of spans.
844+ s = h .free .remove (npage )
884845 if s == nil {
885846 if ! h .grow (npage ) {
886847 return nil
887848 }
888- s = h .allocLarge (npage )
849+ s = h .free . remove (npage )
889850 if s == nil {
890851 return nil
891852 }
892853 }
893854
894- HaveSpan:
895855 // Mark span in use.
896856 if s .state != mSpanFree {
897857 throw ("MHeap_AllocLocked - MSpan not free" )
@@ -933,21 +893,6 @@ HaveSpan:
933893 return s
934894}
935895
936- // Large spans have a minimum size of 1MByte. The maximum number of large spans to support
937- // 1TBytes is 1 million, experimentation using random sizes indicates that the depth of
938- // the tree is less that 2x that of a perfectly balanced tree. For 1TByte can be referenced
939- // by a perfectly balanced tree with a depth of 20. Twice that is an acceptable 40.
940- func (h * mheap ) isLargeSpan (npages uintptr ) bool {
941- return npages >= uintptr (len (h .free ))
942- }
943-
944- // allocLarge allocates a span of at least npage pages from the treap of large spans.
945- // Returns nil if no such span currently exists.
946- func (h * mheap ) allocLarge (npage uintptr ) * mspan {
947- // Search treap for smallest span with >= npage pages.
948- return h .freelarge .remove (npage )
949- }
950-
951896// Try to add at least npage pages of memory to the heap,
952897// returning whether it worked.
953898//
@@ -1023,7 +968,7 @@ func (h *mheap) freeManual(s *mspan, stat *uint64) {
1023968 unlock (& h .lock )
1024969}
1025970
1026- // s must be on a busy list (h.busy or h.busylarge) or unlinked.
971+ // s must be on the busy list or unlinked.
1027972func (h * mheap ) freeSpanLocked (s * mspan , acctinuse , acctidle bool , unusedsince int64 ) {
1028973 switch s .state {
1029974 case mSpanManual :
@@ -1048,7 +993,7 @@ func (h *mheap) freeSpanLocked(s *mspan, acctinuse, acctidle bool, unusedsince i
1048993 }
1049994 s .state = mSpanFree
1050995 if s .inList () {
1051- h .busyList ( s . npages ) .remove (s )
996+ h .busy .remove (s )
1052997 }
1053998
1054999 // Stamp newly unused spans. The scavenger will use that
@@ -1069,12 +1014,7 @@ func (h *mheap) freeSpanLocked(s *mspan, acctinuse, acctidle bool, unusedsince i
10691014 h .setSpan (before .base (), s )
10701015 // The size is potentially changing so the treap needs to delete adjacent nodes and
10711016 // insert back as a combined node.
1072- if h .isLargeSpan (before .npages ) {
1073- // We have a t, it is large so it has to be in the treap so we can remove it.
1074- h .freelarge .removeSpan (before )
1075- } else {
1076- h .freeList (before .npages ).remove (before )
1077- }
1017+ h .free .removeSpan (before )
10781018 before .state = mSpanDead
10791019 h .spanalloc .free (unsafe .Pointer (before ))
10801020 }
@@ -1085,32 +1025,13 @@ func (h *mheap) freeSpanLocked(s *mspan, acctinuse, acctidle bool, unusedsince i
10851025 s .npreleased += after .npreleased
10861026 s .needzero |= after .needzero
10871027 h .setSpan (s .base ()+ s .npages * pageSize - 1 , s )
1088- if h .isLargeSpan (after .npages ) {
1089- h .freelarge .removeSpan (after )
1090- } else {
1091- h .freeList (after .npages ).remove (after )
1092- }
1028+ h .free .removeSpan (after )
10931029 after .state = mSpanDead
10941030 h .spanalloc .free (unsafe .Pointer (after ))
10951031 }
10961032
1097- // Insert s into appropriate list or treap.
1098- if h .isLargeSpan (s .npages ) {
1099- h .freelarge .insert (s )
1100- } else {
1101- h .freeList (s .npages ).insert (s )
1102- }
1103- }
1104-
1105- func (h * mheap ) freeList (npages uintptr ) * mSpanList {
1106- return & h .free [npages ]
1107- }
1108-
1109- func (h * mheap ) busyList (npages uintptr ) * mSpanList {
1110- if npages < uintptr (len (h .busy )) {
1111- return & h .busy [npages ]
1112- }
1113- return & h .busylarge
1033+ // Insert s into the free treap.
1034+ h .free .insert (s )
11141035}
11151036
11161037func scavengeTreapNode (t * treapNode , now , limit uint64 ) uintptr {
@@ -1123,33 +1044,14 @@ func scavengeTreapNode(t *treapNode, now, limit uint64) uintptr {
11231044 return 0
11241045}
11251046
1126- func scavengelist (list * mSpanList , now , limit uint64 ) uintptr {
1127- if list .isEmpty () {
1128- return 0
1129- }
1130-
1131- var sumreleased uintptr
1132- for s := list .first ; s != nil ; s = s .next {
1133- if (now - uint64 (s .unusedsince )) <= limit || s .npreleased == s .npages {
1134- continue
1135- }
1136- sumreleased += s .scavenge ()
1137- }
1138- return sumreleased
1139- }
1140-
11411047func (h * mheap ) scavenge (k int32 , now , limit uint64 ) {
11421048 // Disallow malloc or panic while holding the heap lock. We do
11431049 // this here because this is an non-mallocgc entry-point to
11441050 // the mheap API.
11451051 gp := getg ()
11461052 gp .m .mallocing ++
11471053 lock (& h .lock )
1148- var sumreleased uintptr
1149- for i := 0 ; i < len (h .free ); i ++ {
1150- sumreleased += scavengelist (& h .free [i ], now , limit )
1151- }
1152- sumreleased += scavengetreap (h .freelarge .treap , now , limit )
1054+ sumreleased := scavengetreap (h .free .treap , now , limit )
11531055 unlock (& h .lock )
11541056 gp .m .mallocing --
11551057
0 commit comments