ext/pybind11/tests/test_buffers.cpp - public/gem5 - Git at Google

 /*
     tests/test_buffers.cpp -- supporting Pythons' buffer protocol

     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>

     All rights reserved. Use of this source code is governed by a
     BSD-style license that can be found in the LICENSE file.
 */

 #include "pybind11_tests.h"
 #include "constructor_stats.h"
 #include <pybind11/stl.h>

 TEST_SUBMODULE(buffers, m) {
     // test_from_python / test_to_python:
     class Matrix {
     public:
         Matrix(py::ssize_t rows, py::ssize_t cols) : m_rows(rows), m_cols(cols) {
             print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
             m_data = new float[(size_t) (rows*cols)];
             memset(m_data, 0, sizeof(float) * (size_t) (rows * cols));
         }

         Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
             print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
             m_data = new float[(size_t) (m_rows * m_cols)];
             memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
         }

         Matrix(Matrix &&s) noexcept : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
             print_move_created(this);
             s.m_rows = 0;
             s.m_cols = 0;
             s.m_data = nullptr;
         }

         ~Matrix() {
             print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
             delete[] m_data;
         }

         Matrix &operator=(const Matrix &s) {
             if (this == &s) {
                 return *this;
             }
             print_copy_assigned(this,
                                 std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
             delete[] m_data;
             m_rows = s.m_rows;
             m_cols = s.m_cols;
             m_data = new float[(size_t) (m_rows * m_cols)];
             memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
             return *this;
         }

         Matrix &operator=(Matrix &&s) noexcept {
             print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
             if (&s != this) {
                 delete[] m_data;
                 m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data;
                 s.m_rows = 0; s.m_cols = 0; s.m_data = nullptr;
             }
             return *this;
         }

         float operator()(py::ssize_t i, py::ssize_t j) const {
             return m_data[(size_t) (i*m_cols + j)];
         }

         float &operator()(py::ssize_t i, py::ssize_t j) {
             return m_data[(size_t) (i*m_cols + j)];
         }

         float *data() { return m_data; }

         py::ssize_t rows() const { return m_rows; }
         py::ssize_t cols() const { return m_cols; }
     private:
         py::ssize_t m_rows;
         py::ssize_t m_cols;
         float *m_data;
     };
     py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
         .def(py::init<py::ssize_t, py::ssize_t>())
         /// Construct from a buffer
         .def(py::init([](const py::buffer &b) {
             py::buffer_info info = b.request();
             if (info.format != py::format_descriptor<float>::format() || info.ndim != 2)
                 throw std::runtime_error("Incompatible buffer format!");

             auto v = new Matrix(info.shape[0], info.shape[1]);
             memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols()));
             return v;
         }))

         .def("rows", &Matrix::rows)
         .def("cols", &Matrix::cols)

         /// Bare bones interface
         .def("__getitem__",
              [](const Matrix &m, std::pair<py::ssize_t, py::ssize_t> i) {
                  if (i.first >= m.rows() || i.second >= m.cols())
                      throw py::index_error();
                  return m(i.first, i.second);
              })
         .def("__setitem__",
              [](Matrix &m, std::pair<py::ssize_t, py::ssize_t> i, float v) {
                  if (i.first >= m.rows() || i.second >= m.cols())
                      throw py::index_error();
                  m(i.first, i.second) = v;
              })
         /// Provide buffer access
         .def_buffer([](Matrix &m) -> py::buffer_info {
             return py::buffer_info(
                 m.data(),                               /* Pointer to buffer */
                 { m.rows(), m.cols() },                 /* Buffer dimensions */
                 { sizeof(float) * size_t(m.cols()),     /* Strides (in bytes) for each index */
                   sizeof(float) }
             );
         });

     // test_inherited_protocol
     class SquareMatrix : public Matrix {
     public:
         explicit SquareMatrix(py::ssize_t n) : Matrix(n, n) {}
     };
     // Derived classes inherit the buffer protocol and the buffer access function
     py::class_<SquareMatrix, Matrix>(m, "SquareMatrix")
         .def(py::init<py::ssize_t>());


     // test_pointer_to_member_fn
     // Tests that passing a pointer to member to the base class works in
     // the derived class.
     struct Buffer {
         int32_t value = 0;

         py::buffer_info get_buffer_info() {
             return py::buffer_info(&value, sizeof(value),
                                    py::format_descriptor<int32_t>::format(), 1);
         }
     };
     py::class_<Buffer>(m, "Buffer", py::buffer_protocol())
         .def(py::init<>())
         .def_readwrite("value", &Buffer::value)
         .def_buffer(&Buffer::get_buffer_info);


     class ConstBuffer {
         std::unique_ptr<int32_t> value;

     public:
         int32_t get_value() const { return *value; }
         void set_value(int32_t v) { *value = v; }

         py::buffer_info get_buffer_info() const {
             return py::buffer_info(value.get(), sizeof(*value),
                                    py::format_descriptor<int32_t>::format(), 1);
         }

         ConstBuffer() : value(new int32_t{0}) {}
     };
     py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol())
         .def(py::init<>())
         .def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value)
         .def_buffer(&ConstBuffer::get_buffer_info);

     struct DerivedBuffer : public Buffer { };
     py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol())
         .def(py::init<>())
         .def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value)
         .def_buffer(&DerivedBuffer::get_buffer_info);

     struct BufferReadOnly {
         const uint8_t value = 0;
         explicit BufferReadOnly(uint8_t value) : value(value) {}

         py::buffer_info get_buffer_info() {
             return py::buffer_info(&value, 1);
         }
     };
     py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol())
         .def(py::init<uint8_t>())
         .def_buffer(&BufferReadOnly::get_buffer_info);

     struct BufferReadOnlySelect {
         uint8_t value = 0;
         bool readonly = false;

         py::buffer_info get_buffer_info() {
             return py::buffer_info(&value, 1, readonly);
         }
     };
     py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol())
         .def(py::init<>())
         .def_readwrite("value", &BufferReadOnlySelect::value)
         .def_readwrite("readonly", &BufferReadOnlySelect::readonly)
         .def_buffer(&BufferReadOnlySelect::get_buffer_info);

     // Expose buffer_info for testing.
     py::class_<py::buffer_info>(m, "buffer_info")
         .def(py::init<>())
         .def_readonly("itemsize", &py::buffer_info::itemsize)
         .def_readonly("size", &py::buffer_info::size)
         .def_readonly("format", &py::buffer_info::format)
         .def_readonly("ndim", &py::buffer_info::ndim)
         .def_readonly("shape", &py::buffer_info::shape)
         .def_readonly("strides", &py::buffer_info::strides)
         .def_readonly("readonly", &py::buffer_info::readonly)
         .def("__repr__", [](py::handle self) {
              return py::str("itemsize={0.itemsize!r}, size={0.size!r}, format={0.format!r}, ndim={0.ndim!r}, shape={0.shape!r}, strides={0.strides!r}, readonly={0.readonly!r}").format(self);
         })
         ;

     m.def("get_buffer_info", [](const py::buffer &buffer) { return buffer.request(); });
 }
	/*
	tests/test_buffers.cpp -- supporting Pythons' buffer protocol

	Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>

	All rights reserved. Use of this source code is governed by a
	BSD-style license that can be found in the LICENSE file.
	*/

	#include "pybind11_tests.h"
	#include "constructor_stats.h"
	#include <pybind11/stl.h>

	TEST_SUBMODULE(buffers, m) {
	// test_from_python / test_to_python:
	class Matrix {
	public:
	Matrix(py::ssize_t rows, py::ssize_t cols) : m_rows(rows), m_cols(cols) {
	print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
	m_data = new float[(size_t) (rows*cols)];
	memset(m_data, 0, sizeof(float) * (size_t) (rows * cols));
	}

	Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
	print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
	m_data = new float[(size_t) (m_rows * m_cols)];
	memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
	}

	Matrix(Matrix &&s) noexcept : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
	print_move_created(this);
	s.m_rows = 0;
	s.m_cols = 0;
	s.m_data = nullptr;
	}

	~Matrix() {
	print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
	delete[] m_data;
	}

	Matrix &operator=(const Matrix &s) {
	if (this == &s) {
	return *this;
	}
	print_copy_assigned(this,
	std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
	delete[] m_data;
	m_rows = s.m_rows;
	m_cols = s.m_cols;
	m_data = new float[(size_t) (m_rows * m_cols)];
	memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
	return *this;
	}

	Matrix &operator=(Matrix &&s) noexcept {
	print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
	if (&s != this) {
	delete[] m_data;
	m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data;
	s.m_rows = 0; s.m_cols = 0; s.m_data = nullptr;
	}
	return *this;
	}

	float operator()(py::ssize_t i, py::ssize_t j) const {
	return m_data[(size_t) (i*m_cols + j)];
	}

	float &operator()(py::ssize_t i, py::ssize_t j) {
	return m_data[(size_t) (i*m_cols + j)];
	}

	float *data() { return m_data; }

	py::ssize_t rows() const { return m_rows; }
	py::ssize_t cols() const { return m_cols; }
	private:
	py::ssize_t m_rows;
	py::ssize_t m_cols;
	float *m_data;
	};
	py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
	.def(py::init<py::ssize_t, py::ssize_t>())
	/// Construct from a buffer
	.def(py::init([](const py::buffer &b) {
	py::buffer_info info = b.request();
	if (info.format != py::format_descriptor<float>::format() \|\| info.ndim != 2)
	throw std::runtime_error("Incompatible buffer format!");

	auto v = new Matrix(info.shape[0], info.shape[1]);
	memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols()));
	return v;
	}))

	.def("rows", &Matrix::rows)
	.def("cols", &Matrix::cols)

	/// Bare bones interface
	.def("__getitem__",
	[](const Matrix &m, std::pair<py::ssize_t, py::ssize_t> i) {
	if (i.first >= m.rows() \|\| i.second >= m.cols())
	throw py::index_error();
	return m(i.first, i.second);
	})
	.def("__setitem__",
	[](Matrix &m, std::pair<py::ssize_t, py::ssize_t> i, float v) {
	if (i.first >= m.rows() \|\| i.second >= m.cols())
	throw py::index_error();
	m(i.first, i.second) = v;
	})
	/// Provide buffer access
	.def_buffer([](Matrix &m) -> py::buffer_info {
	return py::buffer_info(
	m.data(), /* Pointer to buffer */
	{ m.rows(), m.cols() }, /* Buffer dimensions */
	{ sizeof(float) * size_t(m.cols()), /* Strides (in bytes) for each index */
	sizeof(float) }
	);
	});

	// test_inherited_protocol
	class SquareMatrix : public Matrix {
	public:
	explicit SquareMatrix(py::ssize_t n) : Matrix(n, n) {}
	};
	// Derived classes inherit the buffer protocol and the buffer access function
	py::class_<SquareMatrix, Matrix>(m, "SquareMatrix")
	.def(py::init<py::ssize_t>());


	// test_pointer_to_member_fn
	// Tests that passing a pointer to member to the base class works in
	// the derived class.
	struct Buffer {
	int32_t value = 0;

	py::buffer_info get_buffer_info() {
	return py::buffer_info(&value, sizeof(value),
	py::format_descriptor<int32_t>::format(), 1);
	}
	};
	py::class_<Buffer>(m, "Buffer", py::buffer_protocol())
	.def(py::init<>())
	.def_readwrite("value", &Buffer::value)
	.def_buffer(&Buffer::get_buffer_info);


	class ConstBuffer {
	std::unique_ptr<int32_t> value;

	public:
	int32_t get_value() const { return *value; }
	void set_value(int32_t v) { *value = v; }

	py::buffer_info get_buffer_info() const {
	return py::buffer_info(value.get(), sizeof(*value),
	py::format_descriptor<int32_t>::format(), 1);
	}

	ConstBuffer() : value(new int32_t{0}) {}
	};
	py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol())
	.def(py::init<>())
	.def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value)
	.def_buffer(&ConstBuffer::get_buffer_info);

	struct DerivedBuffer : public Buffer { };
	py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol())
	.def(py::init<>())
	.def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value)
	.def_buffer(&DerivedBuffer::get_buffer_info);

	struct BufferReadOnly {
	const uint8_t value = 0;
	explicit BufferReadOnly(uint8_t value) : value(value) {}

	py::buffer_info get_buffer_info() {
	return py::buffer_info(&value, 1);
	}
	};
	py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol())
	.def(py::init<uint8_t>())
	.def_buffer(&BufferReadOnly::get_buffer_info);

	struct BufferReadOnlySelect {
	uint8_t value = 0;
	bool readonly = false;

	py::buffer_info get_buffer_info() {
	return py::buffer_info(&value, 1, readonly);
	}
	};
	py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol())
	.def(py::init<>())
	.def_readwrite("value", &BufferReadOnlySelect::value)
	.def_readwrite("readonly", &BufferReadOnlySelect::readonly)
	.def_buffer(&BufferReadOnlySelect::get_buffer_info);

	// Expose buffer_info for testing.
	py::class_<py::buffer_info>(m, "buffer_info")
	.def(py::init<>())
	.def_readonly("itemsize", &py::buffer_info::itemsize)
	.def_readonly("size", &py::buffer_info::size)
	.def_readonly("format", &py::buffer_info::format)
	.def_readonly("ndim", &py::buffer_info::ndim)
	.def_readonly("shape", &py::buffer_info::shape)
	.def_readonly("strides", &py::buffer_info::strides)
	.def_readonly("readonly", &py::buffer_info::readonly)
	.def("__repr__", [](py::handle self) {
	return py::str("itemsize={0.itemsize!r}, size={0.size!r}, format={0.format!r}, ndim={0.ndim!r}, shape={0.shape!r}, strides={0.strides!r}, readonly={0.readonly!r}").format(self);
	})
	;

	m.def("get_buffer_info", [](const py::buffer &buffer) { return buffer.request(); });
	}