Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F86034313
ucl_print.h
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Thu, Oct 3, 20:30
Size
10 KB
Mime Type
text/x-c++
Expires
Sat, Oct 5, 20:30 (1 d, 22 h)
Engine
blob
Format
Raw Data
Handle
21328409
Attached To
rLAMMPS lammps
ucl_print.h
View Options
/***************************************************************************
ucl_print.h
-------------------
W. Michael Brown
Routines for printing debugging output for matrix/vector data
__________________________________________________________________________
This file is part of the Geryon Unified Coprocessor Library (UCL)
__________________________________________________________________________
begin : Mon Jan 11 2010
copyright : (C) 2010 by W. Michael Brown
email : brownw@ornl.gov
***************************************************************************/
/* -----------------------------------------------------------------------
Copyright (2010) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the Simplified BSD License.
----------------------------------------------------------------------- */
// Only allow this file to be included by nvc_memory.h and ocl_memory.h
#ifdef UCL_PRINT_ALLOW
template
<
int
mem
>
struct
_ucl_print
;
template
<>
struct
_ucl_print
<
1
>
{
template
<
class
mat_type
>
static
inline
void
p
(
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
)
{
for
(
size_t
i
=
0
;
i
<
n
-
1
;
i
++
)
out
<<
mat
[
i
]
<<
delim
;
out
<<
mat
[
n
-
1
];
}
template
<
class
mat_type
>
static
inline
void
p
(
const
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
UCL_Device
&
dev
)
{
p
(
mat
,
n
,
out
,
delim
);
}
template
<
class
mat_type
>
static
inline
void
p
(
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
)
{
int
offset
=
0
;
int
row_size
=
cols
;
if
(
mat_type
::
VECTOR
==
0
)
row_size
=
mat
.
row_size
();
for
(
size_t
j
=
0
;
j
<
rows
;
j
++
)
{
size_t
lend
=
offset
+
cols
-
1
;
for
(
size_t
i
=
offset
;
i
<
lend
;
i
++
)
out
<<
mat
[
i
]
<<
delim
;
out
<<
mat
[
lend
];
if
(
j
!=
rows
-
1
)
out
<<
row_delim
;
offset
+=
row_size
;
}
}
template
<
class
mat_type
>
static
inline
void
p
(
const
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
,
UCL_Device
&
dev
)
{
p
(
mat
,
rows
,
cols
,
out
,
delim
,
row_delim
);
}
};
template
<
int
mem
>
struct
_ucl_print
{
template
<
class
mat_type
>
static
inline
void
p
(
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
)
{
UCL_H_Vec
<
typename
mat_type
::
data_type
>
temp
;
temp
.
alloc
(
n
,
mat
);
ucl_copy
(
temp
,
mat
,
n
,
false
);
_ucl_print
<
1
>::
p
(
temp
,
n
,
out
,
delim
);
}
template
<
class
mat_type
>
static
inline
void
p
(
const
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
UCL_Device
&
dev
)
{
UCL_H_Vec
<
typename
mat_type
::
data_type
>
temp
;
temp
.
alloc
(
n
,
dev
);
ucl_copy
(
temp
,
mat
,
n
,
false
);
_ucl_print
<
1
>::
p
(
temp
,
n
,
out
,
delim
);
}
template
<
class
mat_type
>
static
inline
void
p
(
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
)
{
UCL_H_Vec
<
typename
mat_type
::
data_type
>
temp
;
temp
.
alloc
(
mat
.
rows
()
*
mat
.
cols
(),
mat
);
if
(
mat_type
::
VECTOR
==
1
)
ucl_copy
(
temp
,
mat
,
rows
*
cols
,
false
);
else
ucl_copy
(
temp
,
mat
,
rows
,
cols
,
false
);
_ucl_print
<
1
>::
p
(
temp
,
rows
,
cols
,
out
,
delim
,
row_delim
);
}
template
<
class
mat_type
>
static
inline
void
p
(
const
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
,
UCL_Device
&
dev
)
{
UCL_H_Vec
<
typename
mat_type
::
data_type
>
temp
;
temp
.
alloc
(
mat
.
rows
()
*
mat
.
cols
(),
dev
);
if
(
mat_type
::
VECTOR
==
1
)
ucl_copy
(
temp
,
mat
,
rows
*
cols
,
false
);
else
ucl_copy
(
temp
,
mat
,
rows
,
cols
,
false
);
_ucl_print
<
1
>::
p
(
temp
,
rows
,
cols
,
out
,
delim
,
row_delim
);
}
};
// -------------------------------------------------------------------------
// - Non-const routines that do not require a device object
// -------------------------------------------------------------------------
/// Outputs n elements of mat delimited by the string delim
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
)
{
if
(
n
>
mat
.
numel
())
{
std
::
cerr
<<
"Attempted to ucl_print "
<<
n
<<
" elements of matrix "
<<
"that only has "
<<
mat
.
numel
()
<<
" elements."
;
UCL_GERYON_EXIT
;
}
_ucl_print
<
mat_type
::
MEM_TYPE
>::
p
(
mat
,
n
,
out
,
delim
);
}
/// Outputs n elements of mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
)
{
ucl_print
(
mat
,
n
,
out
,
" "
);
}
/// Outputs n elements of mat delimited by a space to standard out
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
n
)
{
ucl_print
(
mat
,
n
,
std
::
cout
,
" "
);
}
/// Outputs upper left rows and cols of mat delimited by the string delim
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
)
{
if
(
rows
*
cols
>
mat
.
numel
())
{
std
::
cerr
<<
"Attempted to ucl_print "
<<
rows
*
cols
<<
" elements of matrix "
<<
"that only has "
<<
mat
.
numel
()
<<
" elements."
;
UCL_GERYON_EXIT
;
}
_ucl_print
<
mat_type
::
MEM_TYPE
>::
p
(
mat
,
rows
,
cols
,
out
,
delim
,
row_delim
);
}
/// Outputs upper left rows and cols of mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
)
{
ucl_print
(
mat
,
rows
,
cols
,
out
,
" "
,
"
\n
"
);
}
/// Outputs upper left rows and cols of mat delimited by a space to std out
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
)
{
ucl_print
(
mat
,
rows
,
cols
,
std
::
cout
,
" "
,
"
\n
"
);
}
/// Outputs mat delimited by a space to standard out
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
)
{
ucl_print
(
mat
,
std
::
cout
);
}
/// Outputs mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
mat_type
&
mat
,
std
::
ostream
&
out
)
{
if
(
mat_type
::
VECTOR
==
1
)
ucl_print
(
mat
,
mat
.
cols
(),
out
,
" "
);
else
ucl_print
(
mat
,
mat
.
rows
(),
mat
.
cols
(),
out
,
" "
,
"
\n
"
);
}
// -------------------------------------------------------------------------
// - Const routines that do not require a device object
// -------------------------------------------------------------------------
/// Outputs n elements of mat delimited by the string delim
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
UCL_Device
&
dev
)
{
if
(
n
>
mat
.
numel
())
{
std
::
cerr
<<
"Attempted to ucl_print "
<<
n
<<
" elements of matrix "
<<
"that only has "
<<
mat
.
numel
()
<<
" elements."
;
UCL_GERYON_EXIT
;
}
_ucl_print
<
mat_type
::
MEM_TYPE
>::
p
(
mat
,
n
,
out
,
delim
,
dev
);
}
/// Outputs n elements of mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
n
,
std
::
ostream
&
out
,
UCL_Device
&
dev
)
{
ucl_print
(
mat
,
n
,
out
,
" "
,
dev
);
}
/// Outputs n elements of mat delimited by a space to standard out
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
n
,
UCL_Device
&
dev
)
{
ucl_print
(
mat
,
n
,
std
::
cout
,
" "
,
dev
);
}
/// Outputs upper left rows and cols of mat delimited by the string delim
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
const
std
::
string
delim
,
const
std
::
string
row_delim
,
UCL_Device
&
dev
)
{
if
(
rows
*
cols
>
mat
.
numel
())
{
std
::
cerr
<<
"Attempted to ucl_print "
<<
rows
*
cols
<<
" elements of matrix "
<<
"that only has "
<<
mat
.
numel
()
<<
" elements."
;
UCL_GERYON_EXIT
;
}
_ucl_print
<
mat_type
::
MEM_TYPE
>::
p
(
mat
,
rows
,
cols
,
out
,
delim
,
row_delim
,
dev
);
}
/// Outputs upper left rows and cols of mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
std
::
ostream
&
out
,
UCL_Device
&
dev
)
{
ucl_print
(
mat
,
rows
,
cols
,
out
,
" "
,
"
\n
"
,
dev
);
}
/// Outputs upper left rows and cols of mat delimited by a space to std out
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
const
size_t
rows
,
const
size_t
cols
,
UCL_Device
&
dev
)
{
ucl_print
(
mat
,
rows
,
cols
,
std
::
cout
,
" "
,
"
\n
"
,
dev
);
}
/// Outputs mat delimited by a space to standard out
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
UCL_Device
&
dev
)
{
ucl_print
(
mat
,
std
::
cout
,
dev
);
}
/// Outputs mat delimited by a space
template
<
class
mat_type
>
inline
void
ucl_print
(
const
mat_type
&
mat
,
std
::
ostream
&
out
,
UCL_Device
&
dev
)
{
if
(
mat_type
::
VECTOR
==
1
)
ucl_print
(
mat
,
mat
.
cols
(),
out
,
" "
,
dev
);
else
ucl_print
(
mat
,
mat
.
rows
(),
mat
.
cols
(),
out
,
" "
,
"
\n
"
,
dev
);
}
// -------------------------------------------------------------------------
// - Operator << Overloading
// -------------------------------------------------------------------------
template
<
class
numtyp
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_H_Vec
<
numtyp
>
&
mat
)
{
ucl_print
(
mat
,
out
);
return
out
;
}
template
<
class
numtyp
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_H_Mat
<
numtyp
>
&
mat
)
{
ucl_print
(
mat
,
out
);
return
out
;
}
template
<
class
numtyp
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_D_Vec
<
numtyp
>
&
mat
)
{
ucl_print
(
mat
,
out
);
return
out
;
}
template
<
class
numtyp
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_D_Mat
<
numtyp
>
&
mat
)
{
ucl_print
(
mat
,
out
);
return
out
;
}
template
<
class
t1
,
class
t2
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_Vector
<
t1
,
t2
>
&
mat
)
{
ucl_print
(
mat
.
host
,
out
);
return
out
;
}
template
<
class
t1
,
class
t2
>
inline
std
::
ostream
&
operator
<<
(
std
::
ostream
&
out
,
UCL_Matrix
<
t1
,
t2
>
&
mat
)
{
ucl_print
(
mat
.
host
,
out
);
return
out
;
}
#endif
Event Timeline
Log In to Comment