Exemple #1
0
// Managing serialization of Pages
func (self *TnyColumn) NewPage() *TnyPage {
	C_key_count := C.int(self.Type.KeyCount())

	page := new(TnyPage)
	page.Column = self
	page.index = len(self.Pages)
	// Also allocate the page_data
	page.cptr = C.tny_page_new(C_key_count, C.int(0))

	self.Pages = append(self.Pages, page)
	self.PageDefinitions = append(self.PageDefinitions, page.GetDefinition())

	return page
}
Exemple #2
0
func ReadPage(reader *bufio.Reader, column *TnyColumn, def *TnyPageDefinition) *TnyPage {

	C_key_count := C.int(column.KeyCount())

	page := new(TnyPage)
	page.Column = column
	page.dirty = false

	var depth, length int32

	binary.Read(reader, binary.LittleEndian, &depth)
	binary.Read(reader, binary.LittleEndian, &length)

	page.cptr = C.tny_page_new(C_key_count, C.int(length))

	// fmt.Printf("Reading page for %s (ptr: %p, len: %d):\n", page.Column.Name, page.cptr, page.Length())

	// C_depth := C.tny_page_depth(page.cptr)

	// fmt.Printf("Reading page for %s (%p):\n", column.Name, page.cptr)
	// Allocate the page in C

	for d := int32(0); d < depth; d++ {
		// Get C to make us a Bitmap so that its aligned and not
		// garbage collected

		// Get the allocated line and make a slice pointing to it that
		// can be updated by the binary.Read
		bmp := page.BitmapAtDepth(int(d))

		// We want a slice that we can pass to binary.Read, but we need
		// to make sure that its not going to get collected, so check this out!

		word_length := (PAGE_MAX_VALUES / 64)

		// Make a slice, then record its header
		bmpSlice := make([]uint64, 1)

		sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&bmpSlice)))

		// Track what it was, so we can set it back and GC can clean that up
		// rather than trashing my actual data
		o_cap := sliceHeader.Cap
		o_len := sliceHeader.Len
		o_data := sliceHeader.Data

		sliceHeader.Cap = (word_length)
		sliceHeader.Len = (word_length)
		sliceHeader.Data = uintptr(unsafe.Pointer(bmp.cptr))

		// fmt.Printf("Pointer pre: %p\n", SlicePointer(bmpSlice))
		// fmt.Printf("Reading data for depth %d...\n", d)
		// This should read my data straight into my C array!
		// Unless it doesnt work ofcourse!

		// Read data from the file into my C array
		err := binary.Read(reader, binary.LittleEndian, bmpSlice)

		// Now that we have read my data, reset the slice back to what it was
		// ready for garbage collection, keeping my C array a secret!  Shhh...
		sliceHeader.Cap = o_cap
		sliceHeader.Len = o_len
		sliceHeader.Data = o_data

		// fmt.Printf("\t%s\n", bmp.BitString(100))

		if err != nil {
			panic("Unable to read page (" + err.Error() + ")")
		}

	}
	def.Loaded = true
	// Test the first few values
	// fmt.Printf("Read Page (%d): ", depth)
	// for i := 0; i < 10; i++ {
	// 	fmt.Printf("%d, ", page.Access(i))
	// }
	// fmt.Printf("\n")

	return page
}