Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Gauthier Quesnel
irritator
Commits
2c2caa73
Commit
2c2caa73
authored
Jun 24, 2020
by
Gauthier Quesnel
Browse files
core: remove useless copy mechanism
parent
e67dcef8
Changes
2
Hide whitespace changes
Inline
Side-by-side
lib/include/irritator/core.hpp
View file @
2c2caa73
...
...
@@ -4538,179 +4538,7 @@ struct simulation
});
}
template
<
typename
Iterator
>
status
copy_connections
(
Iterator
first_orig
,
Iterator
last_orig
,
Iterator
copy
,
const
input_port
&
orig_port
,
const
input_port
&
copy_port
)
noexcept
{
for
(
output_port_id
output_id
:
orig_port
.
connections
)
{
auto
*
output
=
output_ports
.
try_to_get
(
output_id
);
irt_return_if_fail
(
output
,
status
::
dynamics_unknown_port_id
);
auto
it
=
std
::
find
(
first_orig
,
last_orig
,
output
->
model
);
if
(
it
==
last_orig
)
{
irt_return_if_bad
(
connect
(
output_id
,
input_ports
.
get_id
(
copy_port
)));
}
else
{
auto
*
orig_model
=
models
.
try_to_get
(
output
->
model
);
irt_return_if_fail
(
orig_model
,
status
::
dynamics_unknown_id
);
int
index_port
=
-
1
;
irt_return_if_bad
(
get_output_port_index
(
*
orig_model
,
output_id
,
&
index_port
));
auto
index_model
=
std
::
distance
(
first_orig
,
it
);
auto
to_change_id
=
*
(
copy
+
index_model
);
auto
*
to_change_mdl
=
models
.
try_to_get
(
to_change_id
);
irt_return_if_fail
(
to_change_mdl
,
status
::
dynamics_unknown_id
);
output_port_id
copy_port_id
;
irt_return_if_bad
(
get_output_port_id
(
*
to_change_mdl
,
index_port
,
&
copy_port_id
));
connect
(
copy_port_id
,
input_ports
.
get_id
(
copy_port
));
}
}
return
status
::
success
;
}
template
<
typename
Iterator
>
status
copy_connections
(
Iterator
first_orig
,
Iterator
last_orig
,
Iterator
copy
,
const
output_port
&
orig_port
,
const
output_port
&
copy_port
)
noexcept
{
for
(
input_port_id
input_id
:
orig_port
.
connections
)
{
auto
*
input
=
input_ports
.
try_to_get
(
input_id
);
irt_return_if_fail
(
input
,
status
::
dynamics_unknown_port_id
);
auto
it
=
std
::
find
(
first_orig
,
last_orig
,
input
->
model
);
if
(
it
==
last_orig
)
{
irt_return_if_bad
(
connect
(
output_ports
.
get_id
(
copy_port
),
input_id
));
}
else
{
auto
*
orig_model
=
models
.
try_to_get
(
input
->
model
);
irt_return_if_fail
(
orig_model
,
status
::
dynamics_unknown_id
);
int
index_port
=
-
1
;
irt_return_if_bad
(
get_input_port_index
(
*
orig_model
,
input_id
,
&
index_port
));
auto
index_model
=
std
::
distance
(
first_orig
,
it
);
auto
to_change_id
=
*
(
copy
+
index_model
);
auto
*
to_change_mdl
=
models
.
try_to_get
(
to_change_id
);
irt_return_if_fail
(
to_change_mdl
,
status
::
dynamics_unknown_id
);
input_port_id
copy_port_id
;
irt_return_if_bad
(
get_input_port_id
(
*
to_change_mdl
,
index_port
,
&
copy_port_id
));
connect
(
output_ports
.
get_id
(
copy_port
),
copy_port_id
);
}
}
return
status
::
success
;
}
public:
template
<
typename
InputIterator
,
typename
OutputIterator
>
status
copy
(
InputIterator
first
,
InputIterator
last
,
OutputIterator
out
)
{
for
(
auto
it
=
first
,
copy
=
out
;
it
!=
last
;
++
it
,
++
copy
)
{
model_id
model_id
=
*
it
;
const
model
*
mdl
=
models
.
try_to_get
(
model_id
);
irt_return_if_fail
(
mdl
,
status
::
dynamics_unknown_id
);
auto
ret
=
dispatch
(
mdl
->
type
,
[
this
,
&
mdl
,
copy
]
<
typename
DynamicsM
>
(
DynamicsM
&
dynamics_models
)
->
status
{
using
Dynamics
=
typename
DynamicsM
::
value_type
;
irt_return_if_fail
(
dynamics_models
.
can_alloc
(
1
),
status
::
dynamics_not_enough_memory
);
auto
*
dyn_ptr
=
dynamics_models
.
try_to_get
(
mdl
->
id
);
irt_return_if_fail
(
dyn_ptr
,
status
::
dynamics_unknown_id
);
auto
&
new_dyn
=
dynamics_models
.
alloc
(
*
dyn_ptr
);
auto
new_dyn_id
=
dynamics_models
.
get_id
(
new_dyn
);
if
constexpr
(
is_detected_v
<
has_input_port_t
,
Dynamics
>
)
std
::
fill_n
(
new_dyn
.
x
,
std
::
size
(
new_dyn
.
x
),
static_cast
<
input_port_id
>
(
0
));
if
constexpr
(
is_detected_v
<
has_output_port_t
,
Dynamics
>
)
std
::
fill_n
(
new_dyn
.
y
,
std
::
size
(
new_dyn
.
y
),
static_cast
<
output_port_id
>
(
0
));
irt_return_if_bad
(
this
->
alloc
(
new_dyn
,
new_dyn_id
,
mdl
->
name
.
c_str
()));
*
copy
=
new_dyn
.
id
;
return
status
::
success
;
});
irt_return_if_bad
(
ret
);
}
size_t
model_it
=
0
;
for
(
auto
it
=
first
;
it
!=
last
;
++
it
,
++
model_it
)
{
const
model
*
mdl
=
models
.
try_to_get
(
*
(
first
+
model_it
));
irt_return_if_fail
(
mdl
,
status
::
dynamics_unknown_id
);
auto
ret
=
dispatch
(
mdl
->
type
,
[
this
,
model_it
,
first
,
last
,
out
]
<
typename
DynamicsM
>
(
DynamicsM
&
dynamics_models
)
{
using
Dynamics
=
typename
DynamicsM
::
value_type
;
auto
*
mdl_src
=
this
->
models
.
try_to_get
(
*
(
first
+
model_it
));
auto
*
mdl_dst
=
this
->
models
.
try_to_get
(
*
(
out
+
model_it
));
irt_return_if_fail
(
mdl_src
,
status
::
dynamics_unknown_id
);
irt_return_if_fail
(
mdl_dst
,
status
::
dynamics_unknown_id
);
auto
*
dyn_src
=
dynamics_models
.
try_to_get
(
mdl_src
->
id
);
auto
*
dyn_dst
=
dynamics_models
.
try_to_get
(
mdl_dst
->
id
);
irt_return_if_fail
(
dyn_src
,
status
::
dynamics_unknown_id
);
irt_return_if_fail
(
dyn_dst
,
status
::
dynamics_unknown_id
);
if
constexpr
(
is_detected_v
<
has_input_port_t
,
Dynamics
>
)
for
(
size_t
i
=
0
,
e
=
std
::
size
(
dyn_src
->
x
);
i
!=
e
;
++
i
)
copy_connections
(
first
,
last
,
out
,
input_ports
.
get
(
dyn_src
->
x
[
i
]),
input_ports
.
get
(
dyn_dst
->
x
[
i
]));
if
constexpr
(
is_detected_v
<
has_output_port_t
,
Dynamics
>
)
for
(
size_t
i
=
0
,
e
=
std
::
size
(
dyn_src
->
y
);
i
!=
e
;
++
i
)
copy_connections
(
first
,
last
,
out
,
output_ports
.
get
(
dyn_src
->
y
[
i
]),
output_ports
.
get
(
dyn_dst
->
y
[
i
]));
return
status
::
success
;
});
irt_return_if_bad
(
ret
);
}
return
status
::
success
;
}
status
init
(
size_t
model_capacity
,
size_t
messages_capacity
)
{
constexpr
size_t
ten
{
10
};
...
...
lib/test/public-api.cpp
View file @
2c2caa73
...
...
@@ -788,116 +788,6 @@ main()
expect
(
cnt
.
number
==
9
_ul
);
};
"generator_counter_and_copy_simluation"
_test
=
[]
{
irt
::
simulation
sim
;
expect
(
irt
::
is_success
(
sim
.
init
(
16lu
,
256lu
)));
expect
(
sim
.
generator_models
.
can_alloc
(
1
));
expect
(
sim
.
counter_models
.
can_alloc
(
1
));
auto
&
gen
=
sim
.
generator_models
.
alloc
();
auto
&
cnt
=
sim
.
counter_models
.
alloc
();
expect
(
sim
.
models
.
can_alloc
(
2
));
expect
(
irt
::
is_success
(
sim
.
alloc
(
gen
,
sim
.
generator_models
.
get_id
(
gen
))));
expect
(
irt
::
is_success
(
sim
.
alloc
(
cnt
,
sim
.
counter_models
.
get_id
(
cnt
))));
expect
(
sim
.
connect
(
gen
.
y
[
0
],
cnt
.
x
[
0
])
==
irt
::
status
::
success
);
irt
::
model_id
sources
[
2
],
destinations
[
2
];
sources
[
0
]
=
gen
.
id
;
sources
[
1
]
=
cnt
.
id
;
destinations
[
0
]
=
static_cast
<
irt
::
model_id
>
(
0
);
destinations
[
1
]
=
static_cast
<
irt
::
model_id
>
(
0
);
expect
(
sim
.
copy
(
std
::
begin
(
sources
),
std
::
end
(
sources
),
std
::
begin
(
destinations
))
==
irt
::
status
::
success
);
expect
(
destinations
[
0
]
!=
static_cast
<
irt
::
model_id
>
(
0
));
expect
(
destinations
[
1
]
!=
static_cast
<
irt
::
model_id
>
(
0
));
expect
(
destinations
[
0
]
!=
sources
[
0
]);
expect
(
destinations
[
1
]
!=
sources
[
0
]);
expect
(
destinations
[
0
]
!=
sources
[
1
]);
expect
(
destinations
[
1
]
!=
sources
[
1
]);
irt
::
model
&
gen_copy
=
sim
.
models
.
get
(
destinations
[
0
]);
expect
(
gen_copy
.
type
==
irt
::
dynamics_type
::
generator
);
irt
::
model
&
cnt_copy
=
sim
.
models
.
get
(
destinations
[
1
]);
expect
(
cnt_copy
.
type
==
irt
::
dynamics_type
::
counter
);
irt
::
time
t
=
0.0
;
expect
(
sim
.
initialize
(
t
)
==
irt
::
status
::
success
);
expect
(
sim
.
models
.
size
()
==
4
);
irt
::
status
st
;
do
{
st
=
sim
.
run
(
t
);
expect
(
irt
::
is_success
(
st
));
expect
(
cnt
.
number
<=
static_cast
<
irt
::
i64
>
(
t
));
}
while
(
t
<
10.0
);
expect
(
cnt
.
number
==
9
_ul
);
irt
::
counter
*
dyn_cnt_copy
=
sim
.
counter_models
.
try_to_get
(
cnt_copy
.
id
);
expect
(
dyn_cnt_copy
!=
nullptr
);
expect
(
dyn_cnt_copy
->
number
==
9
_ul
);
};
"generators_counter"
_test
=
[]
{
irt
::
simulation
sim
;
expect
(
irt
::
is_success
(
sim
.
init
(
16lu
,
256lu
)));
expect
(
sim
.
generator_models
.
can_alloc
(
1
));
expect
(
sim
.
counter_models
.
can_alloc
(
1
));
auto
&
gen
=
sim
.
generator_models
.
alloc
();
auto
&
cnt
=
sim
.
counter_models
.
alloc
();
expect
(
sim
.
models
.
can_alloc
(
2
));
expect
(
irt
::
is_success
(
sim
.
alloc
(
gen
,
sim
.
generator_models
.
get_id
(
gen
))));
expect
(
irt
::
is_success
(
sim
.
alloc
(
cnt
,
sim
.
counter_models
.
get_id
(
cnt
))));
expect
(
sim
.
connect
(
gen
.
y
[
0
],
cnt
.
x
[
0
])
==
irt
::
status
::
success
);
irt
::
model_id
sources
[
1
],
destinations
[
1
];
sources
[
0
]
=
gen
.
id
;
destinations
[
0
]
=
static_cast
<
irt
::
model_id
>
(
0
);
expect
(
sim
.
copy
(
std
::
begin
(
sources
),
std
::
end
(
sources
),
std
::
begin
(
destinations
))
==
irt
::
status
::
success
);
expect
(
destinations
[
0
]
!=
static_cast
<
irt
::
model_id
>
(
0
));
expect
(
destinations
[
0
]
!=
sources
[
0
]);
destinations
[
0
]
=
static_cast
<
irt
::
model_id
>
(
0
);
expect
(
sim
.
copy
(
std
::
begin
(
sources
),
std
::
end
(
sources
),
std
::
begin
(
destinations
))
==
irt
::
status
::
success
);
expect
(
destinations
[
0
]
!=
static_cast
<
irt
::
model_id
>
(
0
));
expect
(
destinations
[
0
]
!=
sources
[
0
]);
irt
::
time
t
=
0.0
;
expect
(
sim
.
initialize
(
t
)
==
irt
::
status
::
success
);
expect
(
sim
.
models
.
size
()
==
4
);
irt
::
status
st
;
do
{
st
=
sim
.
run
(
t
);
expect
(
irt
::
is_success
(
st
));
expect
(
cnt
.
number
<=
static_cast
<
irt
::
i64
>
(
3
*
t
));
}
while
(
t
<
10.0
);
expect
(
cnt
.
number
==
27
_ul
);
};
"time_func"
_test
=
[]
{
irt
::
simulation
sim
;
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment