gtsam_unstable
timing
timeDSFvariants.cpp
Go to the documentation of this file.
1
/* ----------------------------------------------------------------------------
2
3
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
4
* Atlanta, Georgia 30332-0415
5
* All Rights Reserved
6
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7
8
* See LICENSE for the license information
9
10
* -------------------------------------------------------------------------- */
11
19
#include <
gtsam/base/timing.h
>
20
#include <
gtsam/base/DSFVector.h
>
21
#include <
gtsam_unstable/base/DSF.h
>
22
#include <
gtsam/base/DSFMap.h
>
23
24
#include <fstream>
25
#include <iostream>
26
#include <random>
27
#include <vector>
28
#include <utility>
29
30
using namespace
std
;
31
using namespace
gtsam
;
32
33
int
main
(
int
argc,
char
* argv[]) {
34
35
// Create CSV file for results
36
ofstream
os
(
"dsf-timing.csv"
);
37
os
<<
"images,points,matches,Base,Map,BTree"
<< endl;
38
39
// loop over number of images
40
vector<size_t>
ms
{10, 20, 30, 40, 50, 100, 200, 300, 400, 500, 1000};
41
for
(
size_t
m
:
ms
) {
42
// We use volatile here to make these appear to the optimizing compiler as
43
// if their values are only known at run-time.
44
volatile
size_t
n
= 500;
// number of points per image
45
volatile
size_t
N
=
m
*
n
;
// number of points per image
46
47
volatile
double
fm = 0.1;
// fraction of image pairs matched
48
volatile
size_t
np
= fm *
m
*
m
/ 2;
// number of image pairs
49
volatile
double
fpm = 0.5;
// fraction of points matched
50
volatile
size_t
nm = fpm *
n
*
np
;
// number of matches
51
52
cout <<
"\nTesting with "
<< (
int
)
m
<<
" images, "
<< (
int
)
N
<<
" points, "
<< (
int
)nm <<
" matches\n"
;
53
cout <<
"Generating "
<< nm <<
" matches"
<< endl;
54
std::mt19937
rng
;
55
std::uniform_int_distribution<> rn(0,
N
- 1);
56
57
typedef
pair<size_t, size_t> Match;
58
vector<Match>
matches
;
59
matches
.reserve(nm);
60
for
(
size_t
k = 0; k < nm; k++)
61
matches
.push_back(Match(rn(
rng
), rn(
rng
)));
62
63
os
<< (
int
)
m
<<
","
<< (
int
)
N
<<
","
<< (
int
)nm <<
","
;
64
65
{
66
// DSFBase version
67
double
dsftime = 0;
68
gttic_
(dsftime);
69
DSFBase
dsf(
N
);
// Allow for N keys
70
for
(
const
Match&
m
:
matches
)
71
dsf.
merge
(
m
.first,
m
.second);
72
gttoc_
(dsftime);
73
tictoc_getNode
(dsftimeNode, dsftime);
74
dsftime = dsftimeNode->secs();
75
os
<< dsftime <<
","
;
76
cout <<
"DSFBase: "
<< dsftime <<
" s"
<< endl;
77
tictoc_reset_
();
78
}
79
80
{
81
// DSFMap version
82
double
dsftime = 0;
83
gttic_
(dsftime);
84
DSFMap<size_t>
dsf;
85
for
(
const
Match&
m
:
matches
)
86
dsf.
merge
(
m
.first,
m
.second);
87
gttoc_
(dsftime);
88
tictoc_getNode
(dsftimeNode, dsftime);
89
dsftime = dsftimeNode->secs();
90
os
<< dsftime << endl;
91
cout <<
"DSFMap: "
<< dsftime <<
" s"
<< endl;
92
tictoc_reset_
();
93
}
94
95
if
(
false
) {
96
// DSF version, functional
97
double
dsftime = 0;
98
gttic_
(dsftime);
99
DSF<size_t>
dsf;
100
for
(
size_t
j
= 0;
j
<
N
;
j
++)
101
dsf = dsf.
makeSet
(
j
);
102
for
(
const
Match&
m
:
matches
)
103
dsf = dsf.
makeUnion
(
m
.first,
m
.second);
104
gttoc_
(dsftime);
105
tictoc_getNode
(dsftimeNode, dsftime);
106
dsftime = dsftimeNode->secs();
107
os
<< dsftime << endl;
108
cout <<
"DSF functional: "
<< dsftime <<
" s"
<< endl;
109
tictoc_reset_
();
110
}
111
112
if
(
false
) {
113
// DSF version, in place - always slower - use functional !
114
double
dsftime = 0;
115
gttic_
(dsftime);
116
DSF<size_t>
dsf;
117
for
(
size_t
j
= 0;
j
<
N
;
j
++)
118
dsf.
makeSetInPlace
(
j
);
119
for
(
const
Match&
m
:
matches
)
120
dsf.
makeUnionInPlace
(
m
.first,
m
.second);
121
gttoc_
(dsftime);
122
tictoc_getNode
(dsftimeNode, dsftime);
123
dsftime = dsftimeNode->secs();
124
os
<< dsftime <<
","
;
125
cout <<
"DSF in-place: "
<< dsftime <<
" s"
<< endl;
126
tictoc_reset_
();
127
}
128
129
}
130
131
return
0;
132
133
}
timing.h
Timing utilities.
gtsam.examples.DogLegOptimizerExample.int
int
Definition:
DogLegOptimizerExample.py:111
gtsam::DSF::makeSetInPlace
void makeSetInPlace(const KEY &key)
Definition:
DSF.h:80
rng
static std::mt19937 rng
Definition:
timeFactorOverhead.cpp:31
gtsam::DSF::makeUnion
Self makeUnion(const KEY &key1, const KEY &key2) const
Definition:
DSF.h:92
gtsam::tictoc_reset_
void tictoc_reset_()
Definition:
timing.h:282
gtsam::DSF
Definition:
DSF.h:39
main
int main(int argc, char *argv[])
Definition:
timeDSFvariants.cpp:33
test_eigen.np
np
Definition:
test_eigen.py:5
gtsam::DSFBase::merge
void merge(const size_t &i1, const size_t &i2)
Merge the sets containing i1 and i2. Does nothing if i1 and i2 are already in the same set.
Definition:
DSFVector.cpp:54
os
ofstream os("timeSchurFactors.csv")
gtsam::DSF::makeUnionInPlace
void makeUnionInPlace(const KEY &key1, const KEY &key2)
Definition:
DSF.h:99
n
int n
Definition:
BiCGSTAB_simple.cpp:1
setup.matches
matches
Definition:
wrap/pybind11/setup.py:74
gtsam::DSF::makeSet
Self makeSet(const KEY &key) const
Definition:
DSF.h:72
j
std::ptrdiff_t j
Definition:
tut_arithmetic_redux_minmax.cpp:2
gttoc_
#define gttoc_(label)
Definition:
timing.h:250
DSFMap.h
Allow for arbitrary type in DSF.
gttic_
#define gttic_(label)
Definition:
timing.h:245
tictoc_getNode
#define tictoc_getNode(variable, label)
Definition:
timing.h:276
DSF.h
An implementation of Disjoint set forests (see CLR page 446 and up)
DSFVector.h
A faster implementation for DSF, which uses vector rather than btree.
m
Matrix3f m
Definition:
AngleAxis_mimic_euler.cpp:1
gtsam::DSFMap::merge
void merge(const KEY &x, const KEY &y)
Merge two sets.
Definition:
DSFMap.h:87
gtsam::DSFMap
Definition:
DSFMap.h:34
gtsam
traits
Definition:
SFMdata.h:40
ms
static const double ms
Definition:
TimeOfArrivalExample.cpp:33
std
Definition:
BFloat16.h:88
gtsam::DSFBase
Definition:
DSFVector.h:38
N
#define N
Definition:
igam.h:9
gtsam
Author(s):
autogenerated on Fri Nov 1 2024 03:42:08