gorgonia.org/gorgonia@v0.9.17/cuda/bfc_test.go (about)

     1  package cuda
     2  
     3  import "testing"
     4  
     5  var overlapsTests = []struct {
     6  	a, b     *memblock
     7  	overlaps bool
     8  }{
     9  	{newMemblock(0, 1024), newMemblock(1024, 2048), false},
    10  	{newMemblock(1024, 2048), newMemblock(0, 1024), false},
    11  	{newMemblock(0, 1024), newMemblock(0, 512), true},
    12  	{newMemblock(0, 1024), newMemblock(512, 1024), true},
    13  	{newMemblock(512, 2048), newMemblock(0, 1024), true},
    14  }
    15  
    16  func TestMemblock_overlaps(t *testing.T) {
    17  	for i, ot := range overlapsTests {
    18  		if ot.a.overlaps(ot.b) != ot.overlaps {
    19  			t.Errorf("Test %d Expected Overlap: %v. Got opposite result", i, ot.overlaps)
    20  		}
    21  	}
    22  }
    23  
    24  var memblockLTTests = []struct {
    25  	a, b *memblock
    26  	lt   bool
    27  }{
    28  	{newMemblock(0, 1024), newMemblock(2048, 1024), true},
    29  	{newMemblock(2048, 1024), newMemblock(0, 1024), false},
    30  
    31  	// corner cases - I'm unsure of what the correct result should be for now
    32  	{newMemblock(0, 1024), newMemblock(1024, 1024), false},
    33  	{newMemblock(1024, 1024), newMemblock(0, 1024), false},
    34  
    35  	// overlaps
    36  	{newMemblock(0, 1024), newMemblock(0, 512), false},
    37  }
    38  
    39  func TestMemblock_lt(t *testing.T) {
    40  	for i, ltt := range memblockLTTests {
    41  		if ltt.a.lt(ltt.b) != ltt.lt {
    42  			t.Errorf("Test %d expected to be lt: %v. Got opposite result", i, ltt.lt)
    43  		}
    44  	}
    45  }
    46  
    47  func TestBFC(t *testing.T) {
    48  	align := int64(32)
    49  	bfc := newBFC(align)
    50  	bfc.reserve(0, 1024)
    51  
    52  	_, err := bfc.alloc(0)
    53  	if err == nil {
    54  		t.Error(err)
    55  	}
    56  
    57  	// smaller than alignment
    58  	var addr0 uintptr
    59  	if addr0, err = bfc.alloc(21); err != nil {
    60  		t.Error(err)
    61  	}
    62  	if addr0%uintptr(align) != 0 {
    63  		t.Error("Expected all memories to be well aligned")
    64  	}
    65  	if bfc.freelist.Len() != 2 {
    66  		t.Errorf("Expected the free list to have 2 elements")
    67  	}
    68  	t.Logf("%v", bfc.freelist)
    69  
    70  	// exactly the size of the alignment
    71  	var addr1 uintptr
    72  	if addr1, err = bfc.alloc(align); err != nil {
    73  		t.Error(err)
    74  	}
    75  	if addr1%uintptr(align) != 0 {
    76  		t.Error("Expected all memories to be well aligned")
    77  	}
    78  	if bfc.freelist.Len() != 2 {
    79  		t.Errorf("Expected the free list to have 2 elements. Got %v", bfc.freelist)
    80  	}
    81  
    82  	// larger than alignment
    83  	var addr2 uintptr
    84  	if addr2, err = bfc.alloc(69); err != nil {
    85  		t.Error(err)
    86  	}
    87  	if addr2%uintptr(align) != 0 {
    88  		t.Error("Expected all memories to be well aligned")
    89  	}
    90  	if bfc.freelist.Len() != 3 {
    91  		t.Error("Expected free list to be size of 3")
    92  	}
    93  
    94  	// free memory
    95  	bfc.free(addr1)
    96  	if bfc.freelist.Len() != 4 {
    97  		t.Error("Expected free list to be size of 4")
    98  	}
    99  
   100  	// allocate again, same size as addr1
   101  	var addr3 uintptr
   102  	if addr3, err = bfc.alloc(32); err != nil {
   103  		t.Error(err)
   104  	}
   105  	t.Logf("addr3 %v", addr3)
   106  
   107  	if addr1 != addr3 {
   108  		t.Errorf("Expected addr1 to be reused")
   109  	}
   110  	if bfc.freelist.Len() != 3 {
   111  		t.Errorf("Expected free list to be size of 3 after reusing a block. Got %v", bfc.freelist)
   112  	}
   113  
   114  	// memory's getting fragmented now... let's coalesce
   115  	bfc.free(addr3)
   116  	bfc.free(addr2)
   117  	t.Logf("pre coalesce: %v", bfc.freelist)
   118  	bfc.coalesce()
   119  	t.Logf("post coalesce: %v", bfc.freelist)
   120  }
   121  
   122  func TestBFC_coalesce(t *testing.T) {
   123  	t.SkipNow()
   124  	b := newBFC(32)
   125  	b.reserve(0, 114080)
   126  
   127  	// yanked from a failing real example
   128  	list := []*memblock{
   129  		newMemblock(3280, 16),
   130  		newMemblock(3376, 16),
   131  		newMemblock(3392, 8),
   132  		newMemblock(3400, 24),
   133  		newMemblock(3424, 64),
   134  		newMemblock(3472, 16),
   135  		newMemblock(3488, 110808),
   136  	}
   137  	for i, b := range list {
   138  		if i == len(list)-1 {
   139  			break
   140  		}
   141  		b.next = list[i+1]
   142  		list[i+1].prev = b
   143  	}
   144  	b.freelist.first = list[0]
   145  	b.freelist.last = list[len(list)-1]
   146  
   147  	b.coalesce()
   148  	t.Logf("%v", b.freelist)
   149  }