henry/SimCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ADD: added other eigen lib

Browse Source
This commit is contained in:
Henry Winkel
2022-12-21 16:19:04 +01:00
parent a570766dc6
commit 9e56c7f2c0
832 changed files with 36586 additions and 20006 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
libs/eigen/debug/gdb/printers.py
View File

@@ -22,29 +22,29 @@
# import sys
# sys.path.insert(0, '/path/to/eigen/printer/directory')
# from printers import register_eigen_printers
# register_eigen_printers (None)
# register_eigen_printers(None)
# end
import gdb
import re
import itertools
from bisect import bisect_left
# Basic row/column iteration code for use with Sparse and Dense matrices
class _MatrixEntryIterator(object):
def __init__ (self, rows, cols, rowMajor):
def __init__(self, rows, cols, row_major):
self.rows = rows
self.cols = cols
self.currentRow = 0
self.currentCol = 0
self.rowMajor = rowMajor
self.rowMajor = row_major
def __iter__ (self):
def __iter__(self):
return self
def next(self):
return self.__next__() # Python 2.x compatibility
return self.__next__() # Python 2.x compatibility
def __next__(self):
row = self.currentRow
@@ -53,54 +53,55 @@ class _MatrixEntryIterator(object):
if self.currentCol >= self.cols:
raise StopIteration
self.currentRow = self.currentRow + 1
self.currentRow += 1
if self.currentRow >= self.rows:
self.currentRow = 0
self.currentCol = self.currentCol + 1
self.currentCol += 1
else:
if self.currentRow >= self.rows:
raise StopIteration
self.currentCol = self.currentCol + 1
self.currentCol += 1
if self.currentCol >= self.cols:
self.currentCol = 0
self.currentRow = self.currentRow + 1
self.currentRow += 1
return row, col
return (row, col)
class EigenMatrixPrinter:
"Print Eigen Matrix or Array of some kind"
"""Print Eigen Matrix or Array of some kind"""
def __init__(self, variety, val):
"Extract all the necessary information"
"""Extract all the necessary information"""
# Save the variety (presumably "Matrix" or "Array") for later usage
self.variety = variety
# The gdb extension does not support value template arguments - need to extract them by hand
type = val.type
if type.code == gdb.TYPE_CODE_REF:
type = type.target()
self.type = type.unqualified().strip_typedefs()
typeinfo = val.type
if typeinfo.code == gdb.TYPE_CODE_REF:
typeinfo = typeinfo.target()
self.type = typeinfo.unqualified().strip_typedefs()
tag = self.type.tag
regex = re.compile('\<.*\>')
regex = re.compile('<.*>')
m = regex.findall(tag)[0][1:-1]
template_params = m.split(',')
template_params = [x.replace(" ", "") for x in template_params]
if template_params[1] == '-0x00000000000000001' or template_params[1] == '-0x000000001' or template_params[1] == '-1':
if template_params[1] in ['-0x00000000000000001', '-0x000000001', '-1']:
self.rows = val['m_storage']['m_rows']
else:
self.rows = int(template_params[1])
if template_params[2] == '-0x00000000000000001' or template_params[2] == '-0x000000001' or template_params[2] == '-1':
if template_params[2] in ['-0x00000000000000001', '-0x000000001', '-1']:
self.cols = val['m_storage']['m_cols']
else:
self.cols = int(template_params[2])
self.options = 0 # default value
self.options = 0 # default value
if len(template_params) > 3:
self.options = template_params[3];
self.options = template_params[3]
self.rowMajor = (int(self.options) & 0x1)
@@ -114,50 +115,51 @@ class EigenMatrixPrinter:
self.data = self.data['array']
self.data = self.data.cast(self.innerType.pointer())
class _iterator(_MatrixEntryIterator):
def __init__ (self, rows, cols, dataPtr, rowMajor):
super(EigenMatrixPrinter._iterator, self).__init__(rows, cols, rowMajor)
class _Iterator(_MatrixEntryIterator):
def __init__(self, rows, cols, data_ptr, row_major):
super(EigenMatrixPrinter._Iterator, self).__init__(rows, cols, row_major)
self.dataPtr = dataPtr
self.dataPtr = data_ptr
def __next__(self):
row, col = super(EigenMatrixPrinter._iterator, self).__next__()
row, col = super(EigenMatrixPrinter._Iterator, self).__next__()
item = self.dataPtr.dereference()
self.dataPtr = self.dataPtr + 1
if (self.cols == 1): #if it's a column vector
return ('[%d]' % (row,), item)
elif (self.rows == 1): #if it's a row vector
return ('[%d]' % (col,), item)
return ('[%d,%d]' % (row, col), item)
self.dataPtr += 1
if self.cols == 1: # if it's a column vector
return '[%d]' % (row,), item
elif self.rows == 1: # if it's a row vector
return '[%d]' % (col,), item
return '[%d,%d]' % (row, col), item
def children(self):
return self._iterator(self.rows, self.cols, self.data, self.rowMajor)
return self._Iterator(self.rows, self.cols, self.data, self.rowMajor)
def to_string(self):
return "Eigen::%s<%s,%d,%d,%s> (data ptr: %s)" % (self.variety, self.innerType, self.rows, self.cols, "RowMajor" if self.rowMajor else "ColMajor", self.data)
return "Eigen::%s<%s,%d,%d,%s> (data ptr: %s)" % (
self.variety, self.innerType, self.rows, self.cols,
"RowMajor" if self.rowMajor else "ColMajor", self.data)
class EigenSparseMatrixPrinter:
"Print an Eigen SparseMatrix"
"""Print an Eigen SparseMatrix"""
def __init__(self, val):
"Extract all the necessary information"
"""Extract all the necessary information"""
type = val.type
if type.code == gdb.TYPE_CODE_REF:
type = type.target()
self.type = type.unqualified().strip_typedefs()
typeinfo = val.type
if typeinfo.code == gdb.TYPE_CODE_REF:
typeinfo = typeinfo.target()
self.type = typeinfo.unqualified().strip_typedefs()
tag = self.type.tag
regex = re.compile('\<.*\>')
regex = re.compile('<.*>')
m = regex.findall(tag)[0][1:-1]
template_params = m.split(',')
template_params = [x.replace(" ", "") for x in template_params]
self.options = 0
if len(template_params) > 1:
self.options = template_params[1];
self.options = template_params[1]
self.rowMajor = (int(self.options) & 0x1)
@@ -168,22 +170,23 @@ class EigenSparseMatrixPrinter:
self.data = self.val['m_data']
self.data = self.data.cast(self.innerType.pointer())
class _iterator(_MatrixEntryIterator):
def __init__ (self, rows, cols, val, rowMajor):
super(EigenSparseMatrixPrinter._iterator, self).__init__(rows, cols, rowMajor)
class _Iterator(_MatrixEntryIterator):
def __init__(self, rows, cols, val, row_major):
super(EigenSparseMatrixPrinter._Iterator, self).__init__(rows, cols, row_major)
self.val = val
def __next__(self):
row, col = super(EigenSparseMatrixPrinter._iterator, self).__next__()
row, col = super(EigenSparseMatrixPrinter._Iterator, self).__next__()
# repeat calculations from SparseMatrix.h:
outer = row if self.rowMajor else col
inner = col if self.rowMajor else row
start = self.val['m_outerIndex'][outer]
end = ((start + self.val['m_innerNonZeros'][outer]) if self.val['m_innerNonZeros'] else
self.val['m_outerIndex'][outer+1])
end = (
(start + self.val['m_innerNonZeros'][outer])
if self.val['m_innerNonZeros'] else self.val['m_outerIndex'][outer+1]
)
# and from CompressedStorage.h:
data = self.val['m_data']
@@ -196,20 +199,19 @@ class EigenSparseMatrixPrinter:
indices = [data['m_indices'][x] for x in range(int(start), int(end)-1)]
# find the index with binary search
idx = int(start) + bisect_left(indices, inner)
if ((idx < end) and (data['m_indices'][idx] == inner)):
if idx < end and data['m_indices'][idx] == inner:
item = data['m_values'][idx]
else:
item = 0
return ('[%d,%d]' % (row, col), item)
return '[%d,%d]' % (row, col), item
def children(self):
if self.data:
return self._iterator(self.rows(), self.cols(), self.val, self.rowMajor)
return self._Iterator(self.rows(), self.cols(), self.val, self.rowMajor)
return iter([]) # empty matrix, for now
def rows(self):
return self.val['m_outerSize'] if self.rowMajor else self.val['m_innerSize']
@@ -222,22 +224,23 @@ class EigenSparseMatrixPrinter:
status = ("not compressed" if self.val['m_innerNonZeros'] else "compressed")
else:
status = "empty"
dimensions = "%d x %d" % (self.rows(), self.cols())
layout = "row" if self.rowMajor else "column"
dimensions = "%d x %d" % (self.rows(), self.cols())
layout = "row" if self.rowMajor else "column"
return "Eigen::SparseMatrix<%s>, %s, %s major, %s" % (
self.innerType, dimensions, layout, status )
self.innerType, dimensions, layout, status)
class EigenQuaternionPrinter:
"Print an Eigen Quaternion"
"""Print an Eigen Quaternion"""
def __init__(self, val):
"Extract all the necessary information"
"""Extract all the necessary information"""
# The gdb extension does not support value template arguments - need to extract them by hand
type = val.type
if type.code == gdb.TYPE_CODE_REF:
type = type.target()
self.type = type.unqualified().strip_typedefs()
typeinfo = val.type
if typeinfo.code == gdb.TYPE_CODE_REF:
typeinfo = typeinfo.target()
self.type = typeinfo.unqualified().strip_typedefs()
self.innerType = self.type.template_argument(0)
self.val = val
@@ -245,13 +248,13 @@ class EigenQuaternionPrinter:
self.data = self.val['m_coeffs']['m_storage']['m_data']['array']
self.data = self.data.cast(self.innerType.pointer())
class _iterator:
def __init__ (self, dataPtr):
self.dataPtr = dataPtr
class _Iterator:
def __init__(self, data_ptr):
self.dataPtr = data_ptr
self.currentElement = 0
self.elementNames = ['x', 'y', 'z', 'w']
def __iter__ (self):
def __iter__(self):
return self
def next(self):
@@ -260,47 +263,67 @@ class EigenQuaternionPrinter:
def __next__(self):
element = self.currentElement
if self.currentElement >= 4: #there are 4 elements in a quanternion
if self.currentElement >= 4: # there are 4 elements in a quaternion
raise StopIteration
self.currentElement = self.currentElement + 1
self.currentElement += 1
item = self.dataPtr.dereference()
self.dataPtr = self.dataPtr + 1
return ('[%s]' % (self.elementNames[element],), item)
self.dataPtr += 1
return '[%s]' % (self.elementNames[element],), item
def children(self):
return self._iterator(self.data)
return self._Iterator(self.data)
def to_string(self):
return "Eigen::Quaternion<%s> (data ptr: %s)" % (self.innerType, self.data)
def build_eigen_dictionary ():
def cast_eigen_block_to_matrix(val):
# Get the type of the variable (and convert to a string)
# Example: 'const Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const, -1, -1, false>'
val_type = str(val.type)
# Extract the Eigen::Matrix type from the Block:
# From the previous example: Eigen::Matrix<double, -1, -1, 0, -1, -1>
begin = val_type.find('Eigen::Matrix<')
end = val_type.find('>', begin) + 1
# Convert the Eigen::Block to an Eigen::Matrix
return val.cast(gdb.lookup_type(val_type[begin:end]))
def build_eigen_dictionary():
pretty_printers_dict[re.compile('^Eigen::Quaternion<.*>$')] = lambda val: EigenQuaternionPrinter(val)
pretty_printers_dict[re.compile('^Eigen::Matrix<.*>$')] = lambda val: EigenMatrixPrinter("Matrix", val)
pretty_printers_dict[re.compile('^Eigen::Block<.*>$')] =\
lambda val: EigenMatrixPrinter("Matrix", cast_eigen_block_to_matrix(val))
pretty_printers_dict[re.compile('^Eigen::VectorBlock<.*>$')] =\
lambda val: EigenMatrixPrinter("Matrix", cast_eigen_block_to_matrix(val))
pretty_printers_dict[re.compile('^Eigen::SparseMatrix<.*>$')] = lambda val: EigenSparseMatrixPrinter(val)
pretty_printers_dict[re.compile('^Eigen::Array<.*>$')] = lambda val: EigenMatrixPrinter("Array", val)
pretty_printers_dict[re.compile('^Eigen::Array<.*>$')] = lambda val: EigenMatrixPrinter("Array", val)
def register_eigen_printers(obj):
"Register eigen pretty-printers with objfile Obj"
"""Register eigen pretty-printers with objfile Obj"""
if obj == None:
if obj is None:
obj = gdb
obj.pretty_printers.append(lookup_function)
def lookup_function(val):
"Look-up and return a pretty-printer that can print va."
"""Look-up and return a pretty-printer that can print val."""
type = val.type
typeinfo = val.type
if type.code == gdb.TYPE_CODE_REF:
type = type.target()
if typeinfo.code == gdb.TYPE_CODE_REF:
typeinfo = typeinfo.target()
type = type.unqualified().strip_typedefs()
typeinfo = typeinfo.unqualified().strip_typedefs()
typename = type.tag
if typename == None:
typename = typeinfo.tag
if typename is None:
return None
for function in pretty_printers_dict:
@@ -309,6 +332,7 @@ def lookup_function(val):
return None
pretty_printers_dict = {}
build_eigen_dictionary ()
build_eigen_dictionary()

234
libs/eigen/debug/lldb/eigenlldb.py Normal file
View File

@@ -0,0 +1,234 @@
# -*- coding: utf-8 -*-
# This file is part of Eigen, a lightweight C++ template library
# for linear algebra.
#
# Copyright (C) 2021 Huang, Zhaoquan <zhaoquan2008@hotmail.com>
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
# Pretty printers for Eigen::Matrix to use with LLDB debugger
#
# Usage:
# 1. Add the following line (change it according to the path to this file)
# to the file ~/.lldbinit (create one if it doesn't exist):
# `command script import /path/to/eigenlldb.py`
# 2. Inspect the variables in LLDB command line
# `frame variable`
import lldb
from typing import List
import bisect
def __lldb_init_module(debugger, internal_dict):
debugger.HandleCommand("type synthetic add -x Eigen::Matrix<.*> --python-class eigenlldb.EigenMatrixChildProvider")
debugger.HandleCommand(
"type synthetic add -x Eigen::SparseMatrix<.*> --python-class eigenlldb.EigenSparseMatrixChildProvider")
class EigenMatrixChildProvider:
_valobj: lldb.SBValue
_scalar_type: lldb.SBType
_scalar_size: int
_rows_compile_time: int
_cols_compile_time: int
_row_major: bool
_fixed_storage: bool
def __init__(self, valobj, internal_dict):
self._valobj = valobj
valtype = valobj.GetType().GetCanonicalType()
scalar_type = valtype.GetTemplateArgumentType(0)
if not scalar_type.IsValid():
# In the case that scalar_type is invalid on LLDB 9.0 on Windows with CLion
storage = valobj.GetChildMemberWithName("m_storage")
data = storage.GetChildMemberWithName("m_data")
data_type = data.GetType()
if data_type.IsPointerType():
scalar_type = data.GetType().GetPointeeType()
else:
scalar_type = data.GetChildMemberWithName("array").GetType().GetArrayElementType()
self._scalar_type = scalar_type
self._scalar_size = self._scalar_type.GetByteSize()
name = valtype.GetName()
template_begin = name.find("<")
template_end = name.find(">")
template_args = name[(template_begin + 1):template_end].split(",")
self._rows_compile_time = int(template_args[1])
self._cols_compile_time = int(template_args[2])
self._row_major = (int(template_args[3]) & 1) != 0
max_rows = int(template_args[4])
max_cols = int(template_args[5])
self._fixed_storage = (max_rows != -1 and max_cols != -1)
def num_children(self):
return self._cols() * self._rows()
def get_child_index(self, name):
pass
def get_child_at_index(self, index):
storage = self._valobj.GetChildMemberWithName("m_storage")
data = storage.GetChildMemberWithName("m_data")
offset = self._scalar_size * index
if self._row_major:
row = index // self._cols()
col = index % self._cols()
else:
row = index % self._rows()
col = index // self._rows()
if self._fixed_storage:
data = data.GetChildMemberWithName("array")
if self._cols() == 1:
name = '[{}]'.format(row)
elif self._rows() == 1:
name = '[{}]'.format(col)
else:
name = '[{},{}]'.format(row, col)
return data.CreateChildAtOffset(
name, offset, self._scalar_type
)
def _cols(self):
if self._cols_compile_time == -1:
storage = self._valobj.GetChildMemberWithName("m_storage")
cols = storage.GetChildMemberWithName("m_cols")
return cols.GetValueAsUnsigned()
else:
return self._cols_compile_time
def _rows(self):
if self._rows_compile_time == -1:
storage = self._valobj.GetChildMemberWithName("m_storage")
rows = storage.GetChildMemberWithName("m_rows")
return rows.GetValueAsUnsigned()
else:
return self._rows_compile_time
class EigenSparseMatrixChildProvider:
_valobj: lldb.SBValue
_scalar_type: lldb.SBType
_scalar_size: int
_index_type: lldb.SBType
_index_size: int
_row_major: bool
_outer_size: int
_nnz: int
_values: lldb.SBValue
_inner_indices: lldb.SBValue
_outer_starts: lldb.SBValue
_inner_nnzs: lldb.SBValue
_compressed: bool
# Index of the first synthetic child under each outer index
_child_indices: List[int]
def __init__(self, valobj, internal_dict):
self._valobj = valobj
valtype = valobj.GetType().GetCanonicalType()
scalar_type = valtype.GetTemplateArgumentType(0)
if not scalar_type.IsValid():
# In the case that scalar_type is invalid on LLDB 9.0 on Windows with CLion
data = valobj.GetChildMemberWithName("m_data")
values = data.GetChildMemberWithName("m_values")
scalar_type = values.GetType().GetPointeeType()
self._scalar_type = scalar_type
self._scalar_size = scalar_type.GetByteSize()
index_type = valtype.GetTemplateArgumentType(2)
if not index_type.IsValid():
# In the case that scalar_type is invalid on LLDB 9.0 on Windows with CLion
outer_starts = valobj.GetChildMemberWithName("m_outerIndex")
index_type = outer_starts.GetType().GetPointeeType()
self._index_type = index_type
self._index_size = index_type.GetByteSize()
name = valtype.GetName()
template_begin = name.find("<")
template_end = name.find(">")
template_args = name[(template_begin + 1):template_end].split(",")
self._row_major = (int(template_args[1]) & 1) != 0
def num_children(self):
return self._nnz + 2
def get_child_index(self, name):
pass
def get_child_at_index(self, index):
if index == 0:
name = "rows" if self._row_major else "cols"
return self._valobj.GetChildMemberWithName("m_outerSize") \
.CreateChildAtOffset(name, 0, self._index_type)
elif index == 1:
name = "cols" if self._row_major else "rows"
return self._valobj.GetChildMemberWithName("m_innerSize") \
.CreateChildAtOffset(name, 0, self._index_type)
else:
index = index - 2
outer_index = bisect.bisect_right(self._child_indices, index) - 1
total_nnzs = self._child_indices[outer_index]
if self._compressed:
item_index = index
inner_index = self._inner_indices \
.CreateChildAtOffset("", item_index * self._index_size, self._index_type) \
.GetValueAsUnsigned()
return self._values \
.CreateChildAtOffset(self._child_name(outer_index, inner_index),
item_index * self._scalar_size,
self._scalar_type)
else:
index_begin = self._outer_starts \
.CreateChildAtOffset("", outer_index * self._index_size, self._index_type) \
.GetValueAsUnsigned()
item_index = index - total_nnzs + index_begin
inner_index = self._inner_indices \
.CreateChildAtOffset("", item_index * self._index_size, self._index_type) \
.GetValueAsUnsigned()
return self._values \
.CreateChildAtOffset(self._child_name(outer_index, inner_index),
item_index * self._scalar_size,
self._scalar_type)
def update(self):
valobj = self._valobj
self._outer_size = valobj.GetChildMemberWithName("m_outerSize").GetValueAsUnsigned()
data = valobj.GetChildMemberWithName("m_data")
self._values = data.GetChildMemberWithName("m_values")
self._inner_indices = data.GetChildMemberWithName("m_indices")
self._outer_starts = valobj.GetChildMemberWithName("m_outerIndex")
self._inner_nnzs = valobj.GetChildMemberWithName("m_innerNonZeros")
self._compressed = self._inner_nnzs.GetValueAsUnsigned() == 0
total_nnzs = 0
child_indices = [0]
for outer_index in range(self._outer_size):
if self._compressed:
index_end = self._outer_starts \
.CreateChildAtOffset("", (outer_index + 1) * self._index_size, self._index_type) \
.GetValueAsUnsigned()
total_nnzs = index_end
child_indices.append(total_nnzs)
else:
nnzs = self._inner_nnzs \
.CreateChildAtOffset("", outer_index * self._index_size, self._index_type) \
.GetValueAsUnsigned()
total_nnzs = total_nnzs + nnzs
child_indices.append(total_nnzs)
self._child_indices = child_indices
self._nnz = total_nnzs
def _child_name(self, outer_index, inner_index):
if self._row_major:
return "[{0},{1}]".format(outer_index, inner_index)
else:
return "[{1},{0}]".format(outer_index, inner_index)