Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
O
OpenXG-RAN
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
canghaiwuhen
OpenXG-RAN
Commits
8c76d6ab
Commit
8c76d6ab
authored
Apr 14, 2020
by
Robert Schmidt
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Delete old protobuf slice types flex_slice_{dl,ul}
parent
198822aa
Changes
10
Show whitespace changes
Inline
Side-by-side
Showing
10 changed files
with
45 additions
and
1624 deletions
+45
-1624
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
+12
-194
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
.../ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
+1
-665
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
.../ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
+0
-20
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
...ONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
+0
-343
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
...ONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
+0
-6
openair2/ENB_APP/MESSAGES/V2/config_common.proto
openair2/ENB_APP/MESSAGES/V2/config_common.proto
+0
-77
openair2/ENB_APP/MESSAGES/V2/config_messages.proto
openair2/ENB_APP/MESSAGES/V2/config_messages.proto
+0
-8
openair2/ENB_APP/flexran_agent_common.c
openair2/ENB_APP/flexran_agent_common.c
+1
-19
openair2/ENB_APP/flexran_agent_ran_api.c
openair2/ENB_APP/flexran_agent_ran_api.c
+14
-160
openair2/ENB_APP/flexran_agent_ran_api.h
openair2/ENB_APP/flexran_agent_ran_api.h
+17
-132
No files found.
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
View file @
8c76d6ab
...
@@ -1468,10 +1468,12 @@ void flexran_agent_fill_mac_ue_config(mid_t mod_id, mid_t ue_id,
...
@@ -1468,10 +1468,12 @@ void flexran_agent_fill_mac_ue_config(mid_t mod_id, mid_t ue_id,
ue_conf
->
rnti
=
flexran_get_mac_ue_crnti
(
mod_id
,
ue_id
);
ue_conf
->
rnti
=
flexran_get_mac_ue_crnti
(
mod_id
,
ue_id
);
ue_conf
->
has_rnti
=
1
;
ue_conf
->
has_rnti
=
1
;
ue_conf
->
dl_slice_id
=
flexran_get_ue_dl_slice_id
(
mod_id
,
ue_id
);
int
dl_id
=
flexran_get_ue_dl_slice_id
(
mod_id
,
ue_id
);
ue_conf
->
has_dl_slice_id
=
1
;
ue_conf
->
dl_slice_id
=
dl_id
;
ue_conf
->
ul_slice_id
=
flexran_get_ue_ul_slice_id
(
mod_id
,
ue_id
);
ue_conf
->
has_dl_slice_id
=
dl_id
>=
0
;
ue_conf
->
has_ul_slice_id
=
1
;
int
ul_id
=
flexran_get_ue_ul_slice_id
(
mod_id
,
ue_id
);
ue_conf
->
ul_slice_id
=
ul_id
;
ue_conf
->
has_ul_slice_id
=
ul_id
>=
0
;
ue_conf
->
ue_aggregated_max_bitrate_ul
=
flexran_get_ue_aggregated_max_bitrate_ul
(
mod_id
,
ue_id
);
ue_conf
->
ue_aggregated_max_bitrate_ul
=
flexran_get_ue_aggregated_max_bitrate_ul
(
mod_id
,
ue_id
);
ue_conf
->
has_ue_aggregated_max_bitrate_ul
=
1
;
ue_conf
->
has_ue_aggregated_max_bitrate_ul
=
1
;
...
@@ -1576,149 +1578,24 @@ void flexran_create_config_structures(mid_t mod_id)
...
@@ -1576,149 +1578,24 @@ void flexran_create_config_structures(mid_t mod_id)
sc_update
[
mod_id
]
=
flexran_agent_create_slice_config
(
n_dl
,
m_ul
);
sc_update
[
mod_id
]
=
flexran_agent_create_slice_config
(
n_dl
,
m_ul
);
if
(
!
slice_config
[
mod_id
]
||
!
sc_update
[
mod_id
])
return
;
if
(
!
slice_config
[
mod_id
]
||
!
sc_update
[
mod_id
])
return
;
flexran_agent_read_slice_config
(
mod_id
,
slice_config
[
mod_id
]);
//
flexran_agent_read_slice_config(mod_id, slice_config[mod_id]);
flexran_agent_read_slice_config
(
mod_id
,
sc_update
[
mod_id
]);
//
flexran_agent_read_slice_config(mod_id, sc_update[mod_id]);
for
(
i
=
0
;
i
<
n_dl
;
i
++
)
{
for
(
i
=
0
;
i
<
n_dl
;
i
++
)
{
flexran_agent_read_slice_dl_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
dl
[
i
]);
//
flexran_agent_read_slice_dl_config(mod_id, i, slice_config[mod_id]->dl[i]);
flexran_agent_read_slice_dl_config
(
mod_id
,
i
,
sc_update
[
mod_id
]
->
dl
[
i
]);
//
flexran_agent_read_slice_dl_config(mod_id, i, sc_update[mod_id]->dl[i]);
}
}
for
(
i
=
0
;
i
<
m_ul
;
i
++
)
{
for
(
i
=
0
;
i
<
m_ul
;
i
++
)
{
flexran_agent_read_slice_ul_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
ul
[
i
]);
//
flexran_agent_read_slice_ul_config(mod_id, i, slice_config[mod_id]->ul[i]);
flexran_agent_read_slice_ul_config
(
mod_id
,
i
,
sc_update
[
mod_id
]
->
ul
[
i
]);
//
flexran_agent_read_slice_ul_config(mod_id, i, sc_update[mod_id]->ul[i]);
}
}
}
}
void
flexran_check_and_remove_slices
(
mid_t
mod_id
)
void
flexran_check_and_remove_slices
(
mid_t
mod_id
)
{
{
Protocol__FlexDlSlice
**
dl
=
sc_update
[
mod_id
]
->
dl
;
Protocol__FlexDlSlice
**
dlreal
=
slice_config
[
mod_id
]
->
dl
;
int
i
=
0
;
while
(
i
<
sc_update
[
mod_id
]
->
n_dl
)
{
/* remove slices whose percentage is zero */
if
(
dl
[
i
]
->
percentage
>
0
)
{
++
i
;
continue
;
}
if
(
flexran_remove_dl_slice
(
mod_id
,
i
)
<
1
)
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] can not remove slice index %d ID %d
\n
"
,
mod_id
,
i
,
dl
[
i
]
->
id
);
++
i
;
continue
;
}
LOG_I
(
FLEXRAN_AGENT
,
"[%d] removed slice index %d ID %d
\n
"
,
mod_id
,
i
,
dl
[
i
]
->
id
);
if
(
dl
[
i
]
->
n_sorting
>
0
)
free
(
dl
[
i
]
->
sorting
);
free
(
dl
[
i
]
->
scheduler_name
);
if
(
dlreal
[
i
]
->
n_sorting
>
0
)
{
dlreal
[
i
]
->
n_sorting
=
0
;
free
(
dlreal
[
i
]
->
sorting
);
}
free
(
dlreal
[
i
]
->
scheduler_name
);
--
sc_update
[
mod_id
]
->
n_dl
;
--
slice_config
[
mod_id
]
->
n_dl
;
const
size_t
last
=
sc_update
[
mod_id
]
->
n_dl
;
/* we need to memcpy the higher slice to the position we just deleted */
memcpy
(
dl
[
i
],
dl
[
last
],
sizeof
(
*
dl
[
last
]));
memset
(
dl
[
last
],
0
,
sizeof
(
*
dl
[
last
]));
memcpy
(
dlreal
[
i
],
dlreal
[
last
],
sizeof
(
*
dlreal
[
last
]));
memset
(
dlreal
[
last
],
0
,
sizeof
(
*
dlreal
[
last
]));
/* dont increase i but recheck the slice which has been copied to here */
}
Protocol__FlexUlSlice
**
ul
=
sc_update
[
mod_id
]
->
ul
;
Protocol__FlexUlSlice
**
ulreal
=
slice_config
[
mod_id
]
->
ul
;
i
=
0
;
while
(
i
<
sc_update
[
mod_id
]
->
n_ul
)
{
if
(
ul
[
i
]
->
percentage
>
0
)
{
++
i
;
continue
;
}
if
(
flexran_remove_ul_slice
(
mod_id
,
i
)
<
1
)
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] can not remove slice index %d ID %d
\n
"
,
mod_id
,
i
,
ul
[
i
]
->
id
);
++
i
;
continue
;
}
LOG_I
(
FLEXRAN_AGENT
,
"[%d] removed slice index %d ID %d
\n
"
,
mod_id
,
i
,
ul
[
i
]
->
id
);
free
(
ul
[
i
]
->
scheduler_name
);
free
(
ulreal
[
i
]
->
scheduler_name
);
--
sc_update
[
mod_id
]
->
n_ul
;
--
slice_config
[
mod_id
]
->
n_ul
;
const
size_t
last
=
sc_update
[
mod_id
]
->
n_ul
;
/* see DL remarks */
memcpy
(
ul
[
i
],
ul
[
last
],
sizeof
(
*
ul
[
last
]));
memset
(
ul
[
last
],
0
,
sizeof
(
*
ul
[
last
]));
memcpy
(
ulreal
[
i
],
ulreal
[
last
],
sizeof
(
*
ulreal
[
last
]));
memset
(
ulreal
[
last
],
0
,
sizeof
(
*
ulreal
[
last
]));
/* dont increase i but recheck the slice which has been copied to here */
}
}
}
void
flexran_agent_slice_update
(
mid_t
mod_id
)
void
flexran_agent_slice_update
(
mid_t
mod_id
)
{
{
int
i
;
int
changes
=
0
;
if
(
perform_slice_config_update_count
<=
0
)
return
;
perform_slice_config_update_count
--
;
pthread_mutex_lock
(
&
sc_update_mtx
);
if
(
!
slice_config
[
mod_id
])
{
/* if the configuration does not exist for agent, create from eNB structure
* and exit */
flexran_create_config_structures
(
mod_id
);
pthread_mutex_unlock
(
&
sc_update_mtx
);
return
;
}
/********* read existing config *********/
/* simply update slice_config all the time and write new config
* (apply_new_slice_dl_config() only updates if changes are necessary) */
slice_config
[
mod_id
]
->
n_dl
=
flexran_get_num_dl_slices
(
mod_id
);
slice_config
[
mod_id
]
->
n_ul
=
flexran_get_num_ul_slices
(
mod_id
);
for
(
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_dl
;
i
++
)
{
flexran_agent_read_slice_dl_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
dl
[
i
]);
}
for
(
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_ul
;
i
++
)
{
flexran_agent_read_slice_ul_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
ul
[
i
]);
}
/********* write new config *********/
/* check for removal (sc_update[X]->dl[Y].percentage == 0)
* and update sc_update & slice_config accordingly */
flexran_check_and_remove_slices
(
mod_id
);
/* create new DL and UL slices if necessary */
for
(
i
=
slice_config
[
mod_id
]
->
n_dl
;
i
<
sc_update
[
mod_id
]
->
n_dl
;
i
++
)
{
flexran_create_dl_slice
(
mod_id
,
sc_update
[
mod_id
]
->
dl
[
i
]
->
id
);
}
for
(
i
=
slice_config
[
mod_id
]
->
n_ul
;
i
<
sc_update
[
mod_id
]
->
n_ul
;
i
++
)
{
flexran_create_ul_slice
(
mod_id
,
sc_update
[
mod_id
]
->
ul
[
i
]
->
id
);
}
slice_config
[
mod_id
]
->
n_dl
=
flexran_get_num_dl_slices
(
mod_id
);
slice_config
[
mod_id
]
->
n_ul
=
flexran_get_num_ul_slices
(
mod_id
);
changes
+=
apply_new_slice_config
(
mod_id
,
slice_config
[
mod_id
],
sc_update
[
mod_id
]);
for
(
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_dl
;
i
++
)
{
changes
+=
apply_new_slice_dl_config
(
mod_id
,
slice_config
[
mod_id
]
->
dl
[
i
],
sc_update
[
mod_id
]
->
dl
[
i
]);
flexran_agent_read_slice_dl_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
dl
[
i
]);
}
for
(
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_ul
;
i
++
)
{
changes
+=
apply_new_slice_ul_config
(
mod_id
,
slice_config
[
mod_id
]
->
ul
[
i
],
sc_update
[
mod_id
]
->
ul
[
i
]);
flexran_agent_read_slice_ul_config
(
mod_id
,
i
,
slice_config
[
mod_id
]
->
ul
[
i
]);
}
flexran_agent_read_slice_config
(
mod_id
,
slice_config
[
mod_id
]);
if
(
n_ue_slice_assoc_updates
>
0
)
{
changes
+=
apply_ue_slice_assoc_update
(
mod_id
);
}
if
(
changes
>
0
)
LOG_I
(
FLEXRAN_AGENT
,
"[%d] slice configuration: applied %d changes
\n
"
,
mod_id
,
changes
);
pthread_mutex_unlock
(
&
sc_update_mtx
);
}
}
Protocol__FlexSliceConfig
*
flexran_agent_get_slice_config
(
mid_t
mod_id
)
Protocol__FlexSliceConfig
*
flexran_agent_get_slice_config
(
mid_t
mod_id
)
...
@@ -1727,69 +1604,10 @@ Protocol__FlexSliceConfig *flexran_agent_get_slice_config(mid_t mod_id)
...
@@ -1727,69 +1604,10 @@ Protocol__FlexSliceConfig *flexran_agent_get_slice_config(mid_t mod_id)
Protocol__FlexSliceConfig
*
config
=
NULL
;
Protocol__FlexSliceConfig
*
config
=
NULL
;
pthread_mutex_lock
(
&
sc_update_mtx
);
pthread_mutex_lock
(
&
sc_update_mtx
);
config
=
flexran_agent_create_slice_config
(
slice_config
[
mod_id
]
->
n_dl
,
slice_config
[
mod_id
]
->
n_ul
);
if
(
!
config
)
{
if
(
!
config
)
{
pthread_mutex_unlock
(
&
sc_update_mtx
);
pthread_mutex_unlock
(
&
sc_update_mtx
);
return
NULL
;
return
NULL
;
}
}
config
->
has_intraslice_share_active
=
1
;
config
->
intraslice_share_active
=
slice_config
[
mod_id
]
->
intraslice_share_active
;
config
->
has_interslice_share_active
=
1
;
config
->
interslice_share_active
=
slice_config
[
mod_id
]
->
interslice_share_active
;
for
(
int
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_dl
;
++
i
)
{
if
(
!
config
->
dl
[
i
])
continue
;
config
->
dl
[
i
]
->
has_id
=
1
;
config
->
dl
[
i
]
->
id
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
id
;
config
->
dl
[
i
]
->
has_label
=
1
;
config
->
dl
[
i
]
->
label
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
label
;
config
->
dl
[
i
]
->
has_percentage
=
1
;
config
->
dl
[
i
]
->
percentage
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
percentage
;
config
->
dl
[
i
]
->
has_isolation
=
1
;
config
->
dl
[
i
]
->
isolation
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
isolation
;
config
->
dl
[
i
]
->
has_priority
=
1
;
config
->
dl
[
i
]
->
priority
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
priority
;
config
->
dl
[
i
]
->
has_position_low
=
1
;
config
->
dl
[
i
]
->
position_low
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
position_low
;
config
->
dl
[
i
]
->
has_position_high
=
1
;
config
->
dl
[
i
]
->
position_high
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
position_high
;
config
->
dl
[
i
]
->
has_maxmcs
=
1
;
config
->
dl
[
i
]
->
maxmcs
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
maxmcs
;
config
->
dl
[
i
]
->
n_sorting
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
n_sorting
;
config
->
dl
[
i
]
->
sorting
=
calloc
(
config
->
dl
[
i
]
->
n_sorting
,
sizeof
(
Protocol__FlexDlSorting
));
if
(
!
config
->
dl
[
i
]
->
sorting
)
config
->
dl
[
i
]
->
n_sorting
=
0
;
for
(
int
j
=
0
;
j
<
config
->
dl
[
i
]
->
n_sorting
;
++
j
)
config
->
dl
[
i
]
->
sorting
[
j
]
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
sorting
[
j
];
config
->
dl
[
i
]
->
has_accounting
=
1
;
config
->
dl
[
i
]
->
accounting
=
slice_config
[
mod_id
]
->
dl
[
i
]
->
accounting
;
config
->
dl
[
i
]
->
scheduler_name
=
strdup
(
slice_config
[
mod_id
]
->
dl
[
i
]
->
scheduler_name
);
}
for
(
int
i
=
0
;
i
<
slice_config
[
mod_id
]
->
n_ul
;
++
i
)
{
if
(
!
config
->
ul
[
i
])
continue
;
config
->
ul
[
i
]
->
has_id
=
1
;
config
->
ul
[
i
]
->
id
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
id
;
config
->
ul
[
i
]
->
has_label
=
1
;
config
->
ul
[
i
]
->
label
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
label
;
config
->
ul
[
i
]
->
has_percentage
=
1
;
config
->
ul
[
i
]
->
percentage
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
percentage
;
config
->
ul
[
i
]
->
has_isolation
=
1
;
config
->
ul
[
i
]
->
isolation
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
isolation
;
config
->
ul
[
i
]
->
has_priority
=
1
;
config
->
ul
[
i
]
->
priority
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
priority
;
config
->
ul
[
i
]
->
has_first_rb
=
1
;
config
->
ul
[
i
]
->
first_rb
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
first_rb
;
config
->
ul
[
i
]
->
has_maxmcs
=
1
;
config
->
ul
[
i
]
->
maxmcs
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
maxmcs
;
config
->
ul
[
i
]
->
n_sorting
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
n_sorting
;
config
->
ul
[
i
]
->
sorting
=
calloc
(
config
->
ul
[
i
]
->
n_sorting
,
sizeof
(
Protocol__FlexUlSorting
));
if
(
!
config
->
ul
[
i
]
->
sorting
)
config
->
ul
[
i
]
->
n_sorting
=
0
;
for
(
int
j
=
0
;
j
<
config
->
ul
[
i
]
->
n_sorting
;
++
j
)
config
->
ul
[
i
]
->
sorting
[
j
]
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
sorting
[
j
];
config
->
ul
[
i
]
->
has_accounting
=
1
;
config
->
ul
[
i
]
->
accounting
=
slice_config
[
mod_id
]
->
ul
[
i
]
->
accounting
;
config
->
ul
[
i
]
->
scheduler_name
=
strdup
(
slice_config
[
mod_id
]
->
ul
[
i
]
->
scheduler_name
);
}
pthread_mutex_unlock
(
&
sc_update_mtx
);
pthread_mutex_unlock
(
&
sc_update_mtx
);
return
config
;
return
config
;
}
}
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
View file @
8c76d6ab
...
@@ -1027,666 +1027,18 @@ int load_dl_scheduler_function(mid_t mod_id, const char *function_name) {
...
@@ -1027,666 +1027,18 @@ int load_dl_scheduler_function(mid_t mod_id, const char *function_name) {
Protocol__FlexSliceConfig
*
flexran_agent_create_slice_config
(
int
n_dl
,
int
m_ul
)
Protocol__FlexSliceConfig
*
flexran_agent_create_slice_config
(
int
n_dl
,
int
m_ul
)
{
{
int
i
;
Protocol__FlexSliceConfig
*
fsc
=
malloc
(
sizeof
(
Protocol__FlexSliceConfig
));
Protocol__FlexSliceConfig
*
fsc
=
malloc
(
sizeof
(
Protocol__FlexSliceConfig
));
if
(
!
fsc
)
return
NULL
;
if
(
!
fsc
)
return
NULL
;
protocol__flex_slice_config__init
(
fsc
);
protocol__flex_slice_config__init
(
fsc
);
/* say there are n_dl slices but reserve memory for up to 10 so
/* TODO */
* we don't need to reserve again later */
fsc
->
n_dl
=
n_dl
;
fsc
->
dl
=
calloc
(
10
,
sizeof
(
Protocol__FlexDlSlice
*
));
if
(
!
fsc
->
dl
)
fsc
->
n_dl
=
0
;
for
(
i
=
0
;
i
<
10
;
i
++
)
{
fsc
->
dl
[
i
]
=
malloc
(
sizeof
(
Protocol__FlexDlSlice
));
if
(
!
fsc
->
dl
[
i
])
continue
;
protocol__flex_dl_slice__init
(
fsc
->
dl
[
i
]);
}
/* as above */
fsc
->
n_ul
=
m_ul
;
fsc
->
ul
=
calloc
(
10
,
sizeof
(
Protocol__FlexUlSlice
*
));
if
(
!
fsc
->
ul
)
fsc
->
n_ul
=
0
;
for
(
i
=
0
;
i
<
10
;
i
++
)
{
fsc
->
ul
[
i
]
=
malloc
(
sizeof
(
Protocol__FlexUlSlice
));
if
(
!
fsc
->
ul
[
i
])
continue
;
protocol__flex_ul_slice__init
(
fsc
->
ul
[
i
]);
}
return
fsc
;
return
fsc
;
}
}
void
flexran_agent_read_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
s
)
{
s
->
intraslice_share_active
=
flexran_get_intraslice_sharing_active
(
mod_id
);
s
->
has_intraslice_share_active
=
1
;
s
->
interslice_share_active
=
flexran_get_interslice_sharing_active
(
mod_id
);
s
->
has_interslice_share_active
=
1
;
}
void
flexran_agent_read_slice_dl_config
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSlice
*
dl_slice
)
{
dl_slice
->
id
=
flexran_get_dl_slice_id
(
mod_id
,
slice_idx
);
dl_slice
->
has_id
=
1
;
/* read label from corresponding sc_update entry or give default */
dl_slice
->
label
=
PROTOCOL__FLEX_SLICE_LABEL__xMBB
;
dl_slice
->
has_label
=
1
;
for
(
int
i
=
0
;
i
<
sc_update
[
mod_id
]
->
n_dl
;
i
++
)
{
if
(
sc_update
[
mod_id
]
->
dl
[
i
]
->
id
==
dl_slice
->
id
&&
sc_update
[
mod_id
]
->
dl
[
i
]
->
has_label
)
{
dl_slice
->
label
=
sc_update
[
mod_id
]
->
dl
[
i
]
->
label
;
break
;
}
}
dl_slice
->
percentage
=
flexran_get_dl_slice_percentage
(
mod_id
,
slice_idx
);
dl_slice
->
has_percentage
=
1
;
dl_slice
->
isolation
=
flexran_get_dl_slice_isolation
(
mod_id
,
slice_idx
);
dl_slice
->
has_isolation
=
1
;
dl_slice
->
priority
=
flexran_get_dl_slice_priority
(
mod_id
,
slice_idx
);
dl_slice
->
has_priority
=
1
;
dl_slice
->
position_low
=
flexran_get_dl_slice_position_low
(
mod_id
,
slice_idx
);
dl_slice
->
has_position_low
=
1
;
dl_slice
->
position_high
=
flexran_get_dl_slice_position_high
(
mod_id
,
slice_idx
);
dl_slice
->
has_position_high
=
1
;
dl_slice
->
maxmcs
=
flexran_get_dl_slice_maxmcs
(
mod_id
,
slice_idx
);
dl_slice
->
has_maxmcs
=
1
;
dl_slice
->
n_sorting
=
flexran_get_dl_slice_sorting
(
mod_id
,
slice_idx
,
&
dl_slice
->
sorting
);
if
(
dl_slice
->
n_sorting
<
1
)
dl_slice
->
sorting
=
NULL
;
dl_slice
->
accounting
=
flexran_get_dl_slice_accounting_policy
(
mod_id
,
slice_idx
);
dl_slice
->
has_accounting
=
1
;
const
char
*
s_name
=
flexran_get_dl_slice_scheduler
(
mod_id
,
slice_idx
);
if
(
!
dl_slice
->
scheduler_name
||
strcmp
(
dl_slice
->
scheduler_name
,
s_name
)
!=
0
)
{
dl_slice
->
scheduler_name
=
realloc
(
dl_slice
->
scheduler_name
,
strlen
(
s_name
)
+
1
);
strcpy
(
dl_slice
->
scheduler_name
,
s_name
);
}
}
void
flexran_agent_read_slice_ul_config
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexUlSlice
*
ul_slice
)
{
ul_slice
->
id
=
flexran_get_ul_slice_id
(
mod_id
,
slice_idx
);
ul_slice
->
has_id
=
1
;
/* read label from corresponding sc_update entry or give default */
ul_slice
->
label
=
PROTOCOL__FLEX_SLICE_LABEL__xMBB
;
ul_slice
->
has_label
=
1
;
for
(
int
i
=
0
;
i
<
sc_update
[
mod_id
]
->
n_ul
;
i
++
)
{
if
(
sc_update
[
mod_id
]
->
ul
[
i
]
->
id
==
ul_slice
->
id
&&
sc_update
[
mod_id
]
->
ul
[
i
]
->
has_label
)
{
ul_slice
->
label
=
sc_update
[
mod_id
]
->
ul
[
i
]
->
label
;
break
;
}
}
ul_slice
->
percentage
=
flexran_get_ul_slice_percentage
(
mod_id
,
slice_idx
);
ul_slice
->
has_percentage
=
1
;
/*ul_slice->isolation = flexran_get_ul_slice_isolation(mod_id, slice_idx);*/
ul_slice
->
has_isolation
=
0
;
/*ul_slice->priority = flexran_get_ul_slice_priority(mod_id, slice_idx);*/
ul_slice
->
has_priority
=
0
;
ul_slice
->
first_rb
=
flexran_get_ul_slice_first_rb
(
mod_id
,
slice_idx
);
ul_slice
->
has_first_rb
=
1
;
/*ul_slice-> = flexran_get_ul_slice_length_rb(mod_id, slice_idx);
ul_slice->has_length_rb = 0;*/
ul_slice
->
maxmcs
=
flexran_get_ul_slice_maxmcs
(
mod_id
,
slice_idx
);
ul_slice
->
has_maxmcs
=
1
;
ul_slice
->
n_sorting
=
0
;
/*if (ul_slice->sorting) {
free(ul_slice->sorting);
ul_slice->sorting = NULL;
}
ul_slice->n_sorting = flexran_get_ul_slice_sorting(mod_id, slice_idx, &ul_slice->sorting);
if (ul_slice->n_sorting < 1) ul_slice->sorting = NULL;*/
/*ul_slice->accounting = flexran_get_ul_slice_accounting_policy(mod_id, slice_idx);*/
ul_slice
->
has_accounting
=
0
;
const
char
*
s_name
=
flexran_get_ul_slice_scheduler
(
mod_id
,
slice_idx
);
if
(
!
ul_slice
->
scheduler_name
||
strcmp
(
ul_slice
->
scheduler_name
,
s_name
)
!=
0
)
{
ul_slice
->
scheduler_name
=
realloc
(
ul_slice
->
scheduler_name
,
strlen
(
s_name
)
+
1
);
strcpy
(
ul_slice
->
scheduler_name
,
s_name
);
}
}
int
check_dl_sorting_update
(
Protocol__FlexDlSlice
*
old
,
Protocol__FlexDlSlice
*
new
)
{
/* sorting_update => true when old->n_sorting == 0 or different numbers of
* elements; otherwise will check * element-wise */
int
sorting_update
=
old
->
n_sorting
==
0
||
(
old
->
n_sorting
!=
new
->
n_sorting
);
for
(
int
i
=
0
;
i
<
old
->
n_sorting
&&
!
sorting_update
;
++
i
)
{
sorting_update
=
sorting_update
||
(
new
->
sorting
[
i
]
!=
old
->
sorting
[
i
]);
}
return
sorting_update
;
}
int
check_ul_sorting_update
(
Protocol__FlexUlSlice
*
old
,
Protocol__FlexUlSlice
*
new
)
{
/* sorting_update => true when old->n_sorting == 0 or different numbers of
* elements; otherwise will check * element-wise */
int
sorting_update
=
old
->
n_sorting
==
0
||
(
old
->
n_sorting
!=
new
->
n_sorting
);
for
(
int
i
=
0
;
i
<
old
->
n_sorting
&&
!
sorting_update
;
++
i
)
{
sorting_update
=
sorting_update
||
(
new
->
sorting
[
i
]
!=
old
->
sorting
[
i
]);
}
return
sorting_update
;
}
void
overwrite_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
exist
,
Protocol__FlexSliceConfig
*
update
)
{
if
(
update
->
has_intraslice_share_active
&&
exist
->
intraslice_share_active
!=
update
->
intraslice_share_active
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] update intraslice_share_active: %d -> %d
\n
"
,
mod_id
,
exist
->
intraslice_share_active
,
update
->
intraslice_share_active
);
exist
->
intraslice_share_active
=
update
->
intraslice_share_active
;
exist
->
has_intraslice_share_active
=
1
;
}
if
(
update
->
has_interslice_share_active
&&
exist
->
interslice_share_active
!=
update
->
interslice_share_active
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] update interslice_share_active: %d -> %d
\n
"
,
mod_id
,
exist
->
interslice_share_active
,
update
->
interslice_share_active
);
exist
->
interslice_share_active
=
update
->
interslice_share_active
;
exist
->
has_interslice_share_active
=
1
;
}
}
void
overwrite_slice_config_dl
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
exist
,
Protocol__FlexDlSlice
*
update
)
{
if
(
update
->
label
!=
exist
->
label
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update label: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
label
,
update
->
label
);
exist
->
label
=
update
->
label
;
exist
->
has_label
=
1
;
}
if
(
update
->
percentage
!=
exist
->
percentage
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update percentage: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
percentage
,
update
->
percentage
);
exist
->
percentage
=
update
->
percentage
;
exist
->
has_percentage
=
1
;
}
if
(
update
->
isolation
!=
exist
->
isolation
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update isolation: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
isolation
,
update
->
isolation
);
exist
->
isolation
=
update
->
isolation
;
exist
->
has_isolation
=
1
;
}
if
(
update
->
priority
!=
exist
->
priority
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update priority: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
priority
,
update
->
priority
);
exist
->
priority
=
update
->
priority
;
exist
->
has_priority
=
1
;
}
if
(
update
->
position_low
!=
exist
->
position_low
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update position_low: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
position_low
,
update
->
position_low
);
exist
->
position_low
=
update
->
position_low
;
exist
->
has_position_low
=
1
;
}
if
(
update
->
position_high
!=
exist
->
position_high
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update position_high: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
position_high
,
update
->
position_high
);
exist
->
position_high
=
update
->
position_high
;
exist
->
has_position_high
=
1
;
}
if
(
update
->
maxmcs
!=
exist
->
maxmcs
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update maxmcs: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
maxmcs
,
update
->
maxmcs
);
exist
->
maxmcs
=
update
->
maxmcs
;
exist
->
has_maxmcs
=
1
;
}
if
(
check_dl_sorting_update
(
exist
,
update
))
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update sorting array
\n
"
,
mod_id
,
update
->
id
);
if
(
exist
->
n_sorting
!=
update
->
n_sorting
)
{
exist
->
n_sorting
=
update
->
n_sorting
;
exist
->
sorting
=
realloc
(
exist
->
sorting
,
exist
->
n_sorting
*
sizeof
(
Protocol__FlexDlSorting
));
if
(
!
exist
->
sorting
)
exist
->
n_sorting
=
0
;
}
for
(
int
i
=
0
;
i
<
exist
->
n_sorting
;
i
++
)
exist
->
sorting
[
i
]
=
update
->
sorting
[
i
];
}
if
(
update
->
accounting
!=
exist
->
accounting
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update accounting: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
accounting
,
update
->
accounting
);
exist
->
accounting
=
update
->
accounting
;
exist
->
has_accounting
=
1
;
}
if
(
!
exist
->
scheduler_name
||
strcmp
(
update
->
scheduler_name
,
exist
->
scheduler_name
)
!=
0
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] update scheduler: %s -> %s
\n
"
,
mod_id
,
update
->
id
,
exist
->
scheduler_name
,
update
->
scheduler_name
);
if
(
exist
->
scheduler_name
)
free
(
exist
->
scheduler_name
);
exist
->
scheduler_name
=
strdup
(
update
->
scheduler_name
);
}
}
void
overwrite_slice_config_ul
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
exist
,
Protocol__FlexUlSlice
*
update
)
{
if
(
update
->
label
!=
exist
->
label
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update label: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
label
,
update
->
label
);
exist
->
label
=
update
->
label
;
exist
->
has_label
=
1
;
}
if
(
update
->
percentage
!=
exist
->
percentage
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update percentage: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
percentage
,
update
->
percentage
);
exist
->
percentage
=
update
->
percentage
;
exist
->
has_percentage
=
1
;
}
if
(
update
->
isolation
!=
exist
->
isolation
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update isolation: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
isolation
,
update
->
isolation
);
exist
->
isolation
=
update
->
isolation
;
exist
->
has_isolation
=
1
;
}
if
(
update
->
priority
!=
exist
->
priority
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update priority: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
priority
,
update
->
priority
);
exist
->
priority
=
update
->
priority
;
exist
->
has_priority
=
1
;
}
if
(
update
->
first_rb
!=
exist
->
first_rb
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update first_rb: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
first_rb
,
update
->
first_rb
);
exist
->
first_rb
=
update
->
first_rb
;
exist
->
has_first_rb
=
1
;
}
/*if (update->lenght_rb != exist->lenght_rb) {
LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update lenght_rb: %d -> %d\n",
mod_id, update->id, exist->lenght_rb, update->lenght_rb);
exist->lenght_rb = update->lenght_rb;
}*/
if
(
update
->
maxmcs
!=
exist
->
maxmcs
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update maxmcs: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
maxmcs
,
update
->
maxmcs
);
exist
->
maxmcs
=
update
->
maxmcs
;
exist
->
has_maxmcs
=
1
;
}
/* TODO
int sorting_update = 0;
int n = min(exist->n_sorting, update->n_sorting);
int i = 0;
while (i < n && !sorting_update) {
sorting_update = sorting_update || (update->sorting[i] != exist->sorting[i]);
i++;
}
if (sorting_update) {
LOG_I(FLEXRAN_AGENT, "[%d][UL slice %d] update sorting array\n", update->id, mod_id);
if (exist->n_sorting != update->n_sorting)
LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] only writing %d elements\n",
mod_id, update->id, n);
for (i = 0; i < n; i++)
exist->sorting[i] = update->sorting[i];
}
*/
if
(
update
->
accounting
!=
exist
->
accounting
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update accounting: %d -> %d
\n
"
,
mod_id
,
update
->
id
,
exist
->
accounting
,
update
->
accounting
);
exist
->
accounting
=
update
->
accounting
;
exist
->
has_accounting
=
1
;
}
if
(
!
exist
->
scheduler_name
||
strcmp
(
update
->
scheduler_name
,
exist
->
scheduler_name
)
!=
0
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] update scheduler: %s -> %s
\n
"
,
mod_id
,
update
->
id
,
exist
->
scheduler_name
,
update
->
scheduler_name
);
if
(
exist
->
scheduler_name
)
free
(
exist
->
scheduler_name
);
exist
->
scheduler_name
=
strdup
(
update
->
scheduler_name
);
}
}
void
fill_dl_slice
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
s
,
Protocol__FlexDlSlice
*
from
)
{
/* function fills slice with information from another slice or with default
* values (currently slice 0) if from is NULL */
/* TODO fill the slice depending on the chosen label */
if
(
!
s
->
has_label
)
{
s
->
has_label
=
1
;
s
->
label
=
from
?
from
->
label
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
label
;
}
if
(
!
s
->
has_percentage
)
{
s
->
has_percentage
=
1
;
s
->
percentage
=
from
?
from
->
percentage
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
percentage
;
}
if
(
!
s
->
has_isolation
)
{
s
->
has_isolation
=
1
;
s
->
isolation
=
from
?
from
->
isolation
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
isolation
;
}
if
(
!
s
->
has_priority
)
{
s
->
has_priority
=
1
;
s
->
priority
=
from
?
from
->
priority
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
priority
;
}
if
(
!
s
->
has_position_low
)
{
s
->
has_position_low
=
1
;
s
->
position_low
=
from
?
from
->
position_low
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
position_low
;
}
if
(
!
s
->
has_position_high
)
{
s
->
has_position_high
=
1
;
s
->
position_high
=
from
?
from
->
position_high
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
position_high
;
}
if
(
!
s
->
has_maxmcs
)
{
s
->
has_maxmcs
=
1
;
s
->
maxmcs
=
from
?
from
->
maxmcs
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
maxmcs
;
}
if
(
s
->
n_sorting
==
0
)
{
s
->
n_sorting
=
from
?
from
->
n_sorting
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
n_sorting
;
s
->
sorting
=
calloc
(
s
->
n_sorting
,
sizeof
(
Protocol__FlexDlSorting
));
if
(
!
s
->
sorting
)
s
->
n_sorting
=
0
;
for
(
int
i
=
0
;
i
<
s
->
n_sorting
;
++
i
)
s
->
sorting
[
i
]
=
from
?
from
->
sorting
[
i
]
:
sc_update
[
0
]
->
dl
[
0
]
->
sorting
[
i
];
}
if
(
!
s
->
has_accounting
)
{
s
->
accounting
=
from
?
from
->
accounting
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
accounting
;
}
if
(
!
s
->
scheduler_name
)
{
s
->
scheduler_name
=
strdup
(
from
?
from
->
scheduler_name
:
sc_update
[
mod_id
]
->
dl
[
0
]
->
scheduler_name
);
}
}
Protocol__FlexDlSlice
*
get_existing_dl_slice
(
mid_t
mod_id
,
int
id
)
{
for
(
int
i
=
0
;
i
<
sc_update
[
mod_id
]
->
n_dl
;
++
i
)
{
if
(
id
==
sc_update
[
mod_id
]
->
dl
[
i
]
->
id
)
{
return
sc_update
[
mod_id
]
->
dl
[
i
];
}
}
return
NULL
;
}
Protocol__FlexDlSlice
*
create_new_dl_slice
(
mid_t
mod_id
,
int
id
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] Creating DL slice with ID %d, taking default values from DL slice 0
\n
"
,
mod_id
,
id
);
Protocol__FlexDlSlice
*
to
=
sc_update
[
mod_id
]
->
dl
[
sc_update
[
mod_id
]
->
n_dl
];
sc_update
[
mod_id
]
->
n_dl
++
;
AssertFatal
(
sc_update
[
mod_id
]
->
n_dl
<=
10
,
"cannot create more than 10
\n
"
);
to
->
id
=
id
;
return
to
;
}
void
fill_ul_slice
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
s
,
Protocol__FlexUlSlice
*
from
)
{
/* function fills slice with information from another slice or with default
* values (currently slice 0) if from is NULL */
/* TODO fill the slice depending on the chosen label */
if
(
!
s
->
has_label
)
{
s
->
has_label
=
1
;
s
->
label
=
from
?
from
->
label
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
label
;
}
if
(
!
s
->
has_percentage
)
{
s
->
has_percentage
=
1
;
s
->
percentage
=
from
?
from
->
percentage
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
percentage
;
}
if
(
!
s
->
has_isolation
)
{
s
->
has_isolation
=
1
;
s
->
isolation
=
from
?
from
->
isolation
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
isolation
;
}
if
(
!
s
->
has_priority
)
{
s
->
has_priority
=
1
;
s
->
priority
=
from
?
from
->
priority
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
priority
;
}
if
(
!
s
->
has_first_rb
)
{
s
->
has_first_rb
=
1
;
s
->
first_rb
=
from
?
from
->
first_rb
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
first_rb
;
}
if
(
!
s
->
has_maxmcs
)
{
s
->
has_maxmcs
=
1
;
s
->
maxmcs
=
from
?
from
->
maxmcs
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
maxmcs
;
}
if
(
s
->
n_sorting
==
0
)
{
s
->
n_sorting
=
from
?
from
->
n_sorting
:
sc_update
[
0
]
->
ul
[
0
]
->
n_sorting
;
s
->
sorting
=
calloc
(
s
->
n_sorting
,
sizeof
(
Protocol__FlexUlSorting
));
if
(
!
s
->
sorting
)
s
->
n_sorting
=
0
;
for
(
int
i
=
0
;
i
<
s
->
n_sorting
;
++
i
)
s
->
sorting
[
i
]
=
from
?
from
->
sorting
[
i
]
:
sc_update
[
0
]
->
ul
[
0
]
->
sorting
[
i
];
}
if
(
!
s
->
has_accounting
)
{
s
->
accounting
=
from
?
from
->
accounting
:
sc_update
[
0
]
->
ul
[
0
]
->
accounting
;
}
if
(
!
s
->
scheduler_name
)
{
s
->
scheduler_name
=
strdup
(
from
?
from
->
scheduler_name
:
sc_update
[
mod_id
]
->
ul
[
0
]
->
scheduler_name
);
}
}
Protocol__FlexUlSlice
*
get_existing_ul_slice
(
mid_t
mod_id
,
int
id
)
{
for
(
int
i
=
0
;
i
<
sc_update
[
mod_id
]
->
n_ul
;
++
i
)
{
if
(
id
==
sc_update
[
mod_id
]
->
ul
[
i
]
->
id
)
{
return
sc_update
[
mod_id
]
->
ul
[
i
];
}
}
return
NULL
;
}
Protocol__FlexUlSlice
*
create_new_ul_slice
(
mid_t
mod_id
,
int
id
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] Creating UL slice with ID %d, taking default values from UL slice 0
\n
"
,
mod_id
,
id
);
Protocol__FlexUlSlice
*
to
=
sc_update
[
mod_id
]
->
ul
[
sc_update
[
mod_id
]
->
n_ul
];
sc_update
[
mod_id
]
->
n_ul
++
;
AssertFatal
(
sc_update
[
mod_id
]
->
n_ul
<=
10
,
"cannot create more than 10
\n
"
);
to
->
id
=
id
;
return
to
;
}
void
prepare_update_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
sup
)
void
prepare_update_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
sup
)
{
{
int
verified
=
1
;
if
(
!
sc_update
[
mod_id
])
{
LOG_E
(
FLEXRAN_AGENT
,
"Can not update slice policy (no existing slice profile)
\n
"
);
return
;
}
pthread_mutex_lock
(
&
sc_update_mtx
);
/* no need for tests in the current state as there are only two protobuf
* bools for intra-/interslice sharing. The function applies new values if
* applicable */
overwrite_slice_config
(
mod_id
,
sc_update
[
mod_id
],
sup
);
if
(
sup
->
n_dl
==
0
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] no DL slice configuration in flex_slice_config message
\n
"
,
mod_id
);
}
else
{
/* verify slice parameters */
for
(
int
i
=
0
;
i
<
sup
->
n_dl
;
i
++
)
{
if
(
!
sup
->
dl
[
i
]
->
has_id
)
{
verified
=
0
;
break
;
}
Protocol__FlexDlSlice
*
dls
=
get_existing_dl_slice
(
mod_id
,
sup
->
dl
[
i
]
->
id
);
/* fill up so that the slice is complete. This way, we don't need to
* worry about it later */
fill_dl_slice
(
mod_id
,
sup
->
dl
[
i
],
dls
);
verified
=
verified
&&
flexran_verify_dl_slice
(
mod_id
,
sup
->
dl
[
i
]);
if
(
!
verified
)
break
;
}
/* verify group-based parameters (e.g. sum percentage should not exceed
* 100%). Can be used to perform admission control */
verified
=
verified
&&
flexran_verify_group_dl_slices
(
mod_id
,
sc_update
[
mod_id
]
->
dl
,
sc_update
[
mod_id
]
->
n_dl
,
sup
->
dl
,
sup
->
n_dl
);
if
(
verified
)
{
for
(
int
i
=
0
;
i
<
sup
->
n_dl
;
i
++
)
{
/* if all verifications were successful, get existing slice for ID or
* create new one and overwrite with the update */
Protocol__FlexDlSlice
*
dls
=
get_existing_dl_slice
(
mod_id
,
sup
->
dl
[
i
]
->
id
);
if
(
!
dls
)
dls
=
create_new_dl_slice
(
mod_id
,
sup
->
dl
[
i
]
->
id
);
overwrite_slice_config_dl
(
mod_id
,
dls
,
sup
->
dl
[
i
]);
}
}
else
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] DL slice verification failed, refusing application
\n
"
,
mod_id
);
}
}
verified
=
1
;
if
(
sup
->
n_ul
==
0
)
{
LOG_I
(
FLEXRAN_AGENT
,
"[%d] no UL slice configuration in flex_slice_config message
\n
"
,
mod_id
);
}
else
{
/* verify slice parameters */
for
(
int
i
=
0
;
i
<
sup
->
n_ul
;
i
++
)
{
if
(
!
sup
->
ul
[
i
]
->
has_id
)
{
verified
=
0
;
break
;
}
Protocol__FlexUlSlice
*
uls
=
get_existing_ul_slice
(
mod_id
,
sup
->
ul
[
i
]
->
id
);
/* fill up so that the slice is complete. This way, we don't need to
* worry about it later */
fill_ul_slice
(
mod_id
,
sup
->
ul
[
i
],
uls
);
verified
=
verified
&&
flexran_verify_ul_slice
(
mod_id
,
sup
->
ul
[
i
]);
if
(
!
verified
)
break
;
}
/* verify group-based parameters (e.g. sum percentage should not exceed
* 100%). Can be used to perform admission control */
verified
=
verified
&&
flexran_verify_group_ul_slices
(
mod_id
,
sc_update
[
mod_id
]
->
ul
,
sc_update
[
mod_id
]
->
n_ul
,
sup
->
ul
,
sup
->
n_ul
);
if
(
verified
)
{
for
(
int
i
=
0
;
i
<
sup
->
n_ul
;
i
++
)
{
/* if all verifications were successful, get existing slice for ID or
* create new one and overwrite with the update */
Protocol__FlexUlSlice
*
uls
=
get_existing_ul_slice
(
mod_id
,
sup
->
ul
[
i
]
->
id
);
if
(
!
uls
)
uls
=
create_new_ul_slice
(
mod_id
,
sup
->
ul
[
i
]
->
id
);
overwrite_slice_config_ul
(
mod_id
,
uls
,
sup
->
ul
[
i
]);
}
}
else
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] UL slice verification failed, refusing application
\n
"
,
mod_id
);
}
}
pthread_mutex_unlock
(
&
sc_update_mtx
);
perform_slice_config_update_count
=
1
;
}
}
int
apply_new_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
olds
,
Protocol__FlexSliceConfig
*
news
)
{
/* not setting the old configuration is intentional, as it will be picked up
* later when reading the configuration. There is thus a direct feedback
* whether it has been set. */
int
changes
=
0
;
if
(
olds
->
intraslice_share_active
!=
news
->
intraslice_share_active
)
{
flexran_set_intraslice_sharing_active
(
mod_id
,
news
->
intraslice_share_active
);
changes
++
;
}
if
(
olds
->
interslice_share_active
!=
news
->
interslice_share_active
)
{
flexran_set_interslice_sharing_active
(
mod_id
,
news
->
interslice_share_active
);
changes
++
;
}
return
changes
;
}
int
apply_new_slice_dl_config
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
oldc
,
Protocol__FlexDlSlice
*
newc
)
{
/* not setting the old configuration is intentional, as it will be picked up
* later when reading the configuration. There is thus a direct feedback
* whether it has been set. */
int
changes
=
0
;
int
slice_idx
=
flexran_find_dl_slice
(
mod_id
,
newc
->
id
);
if
(
slice_idx
<
0
)
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] cannot find index for slice ID %d
\n
"
,
mod_id
,
newc
->
id
);
return
0
;
}
if
(
oldc
->
percentage
!=
newc
->
percentage
)
{
flexran_set_dl_slice_percentage
(
mod_id
,
slice_idx
,
newc
->
percentage
);
changes
++
;
}
if
(
oldc
->
isolation
!=
newc
->
isolation
)
{
flexran_set_dl_slice_isolation
(
mod_id
,
slice_idx
,
newc
->
isolation
);
changes
++
;
}
if
(
oldc
->
priority
!=
newc
->
priority
)
{
flexran_set_dl_slice_priority
(
mod_id
,
slice_idx
,
newc
->
priority
);
changes
++
;
}
if
(
oldc
->
position_low
!=
newc
->
position_low
)
{
flexran_set_dl_slice_position_low
(
mod_id
,
slice_idx
,
newc
->
position_low
);
changes
++
;
}
if
(
oldc
->
position_high
!=
newc
->
position_high
)
{
flexran_set_dl_slice_position_high
(
mod_id
,
slice_idx
,
newc
->
position_high
);
changes
++
;
}
if
(
oldc
->
maxmcs
!=
newc
->
maxmcs
)
{
flexran_set_dl_slice_maxmcs
(
mod_id
,
slice_idx
,
newc
->
maxmcs
);
changes
++
;
}
if
(
check_dl_sorting_update
(
oldc
,
newc
))
{
flexran_set_dl_slice_sorting
(
mod_id
,
slice_idx
,
newc
->
sorting
,
newc
->
n_sorting
);
changes
++
;
}
if
(
oldc
->
accounting
!=
newc
->
accounting
)
{
flexran_set_dl_slice_accounting_policy
(
mod_id
,
slice_idx
,
newc
->
accounting
);
changes
++
;
}
if
(
!
oldc
->
scheduler_name
||
strcmp
(
oldc
->
scheduler_name
,
newc
->
scheduler_name
)
!=
0
)
{
int
ret
=
flexran_set_dl_slice_scheduler
(
mod_id
,
slice_idx
,
newc
->
scheduler_name
);
AssertFatal
(
ret
,
"could not set DL slice scheduler for slice %d idx %d
\n
"
,
newc
->
id
,
slice_idx
);
changes
++
;
}
return
changes
;
}
int
apply_new_slice_ul_config
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
oldc
,
Protocol__FlexUlSlice
*
newc
)
{
/* not setting the old configuration is intentional, as it will be picked up
* later when reading the configuration. There is thus a direct feedback
* whether it has been set. */
int
changes
=
0
;
int
slice_idx
=
flexran_find_ul_slice
(
mod_id
,
newc
->
id
);
if
(
slice_idx
<
0
)
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] cannot find index for slice ID %d
\n
"
,
mod_id
,
newc
->
id
);
return
0
;
}
if
(
oldc
->
percentage
!=
newc
->
percentage
)
{
flexran_set_ul_slice_percentage
(
mod_id
,
slice_idx
,
newc
->
percentage
);
changes
++
;
}
if
(
oldc
->
isolation
!=
newc
->
isolation
)
{
/*flexran_set_ul_slice_isolation(mod_id, slice_idx, newc->isolation);
*changes++;*/
LOG_W
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] setting isolation is not supported
\n
"
,
mod_id
,
newc
->
id
);
}
if
(
oldc
->
priority
!=
newc
->
priority
)
{
/*flexran_set_ul_slice_priority(mod_id, slice_idx, newc->priority);
*changes++;*/
LOG_W
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] setting the priority is not supported
\n
"
,
mod_id
,
newc
->
id
);
}
if
(
oldc
->
first_rb
!=
newc
->
first_rb
)
{
flexran_set_ul_slice_first_rb
(
mod_id
,
slice_idx
,
newc
->
first_rb
);
changes
++
;
}
/*if (oldc->length_rb != newc->length_rb) {
flexran_set_ul_slice_length_rb(mod_id, slice_idx, newc->length_rb);
changes++;
LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting length_rb is not supported\n",
mod_id, newc->id);
}*/
if
(
oldc
->
maxmcs
!=
newc
->
maxmcs
)
{
flexran_set_ul_slice_maxmcs
(
mod_id
,
slice_idx
,
newc
->
maxmcs
);
changes
++
;
}
/*if (check_ul_sorting_update(oldc, newc)) {
flexran_set_ul_slice_sorting(mod_id, slice_idx, newc->sorting, n);
changes++;
LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the sorting is not supported\n",
mod_id, newc->id);
}*/
if
(
oldc
->
accounting
!=
newc
->
accounting
)
{
/*flexran_set_ul_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
*changes++;*/
LOG_W
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] setting the accounting is not supported
\n
"
,
mod_id
,
newc
->
id
);
}
if
(
!
oldc
->
scheduler_name
||
strcmp
(
oldc
->
scheduler_name
,
newc
->
scheduler_name
)
!=
0
)
{
int
ret
=
flexran_set_ul_slice_scheduler
(
mod_id
,
slice_idx
,
newc
->
scheduler_name
);
AssertFatal
(
ret
,
"could not set DL slice scheduler for slice %d idx %d
\n
"
,
newc
->
id
,
slice_idx
);
changes
++
;
}
return
changes
;
}
void
prepare_ue_slice_assoc_update
(
mid_t
mod_id
,
Protocol__FlexUeConfig
*
ue_config
)
void
prepare_ue_slice_assoc_update
(
mid_t
mod_id
,
Protocol__FlexUeConfig
*
ue_config
)
{
{
...
@@ -1723,24 +1075,8 @@ int apply_ue_slice_assoc_update(mid_t mod_id)
...
@@ -1723,24 +1075,8 @@ int apply_ue_slice_assoc_update(mid_t mod_id)
continue
;
continue
;
}
}
if
(
ue_slice_assoc_update
[
i
]
->
has_dl_slice_id
)
{
if
(
ue_slice_assoc_update
[
i
]
->
has_dl_slice_id
)
{
int
slice_idx
=
flexran_find_dl_slice
(
mod_id
,
ue_slice_assoc_update
[
i
]
->
dl_slice_id
);
if
(
flexran_dl_slice_exists
(
mod_id
,
slice_idx
))
{
flexran_set_ue_dl_slice_idx
(
mod_id
,
ue_id
,
slice_idx
);
changes
++
;
}
else
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] DL slice %d does not exist, refusing change
\n
"
,
mod_id
,
ue_slice_assoc_update
[
i
]
->
dl_slice_id
);
}
}
}
if
(
ue_slice_assoc_update
[
i
]
->
has_ul_slice_id
)
{
if
(
ue_slice_assoc_update
[
i
]
->
has_ul_slice_id
)
{
int
slice_idx
=
flexran_find_ul_slice
(
mod_id
,
ue_slice_assoc_update
[
i
]
->
ul_slice_id
);
if
(
flexran_ul_slice_exists
(
mod_id
,
slice_idx
))
{
flexran_set_ue_ul_slice_idx
(
mod_id
,
ue_id
,
slice_idx
);
changes
++
;
}
else
{
LOG_W
(
FLEXRAN_AGENT
,
"[%d] UL slice %d does not exist, refusing change
\n
"
,
mod_id
,
ue_slice_assoc_update
[
i
]
->
ul_slice_id
);
}
}
}
}
}
n_ue_slice_assoc_updates
=
0
;
n_ue_slice_assoc_updates
=
0
;
...
...
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h
View file @
8c76d6ab
...
@@ -111,30 +111,10 @@ Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
...
@@ -111,30 +111,10 @@ Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
* Protocol__FlexSliceConfig struct */
* Protocol__FlexSliceConfig struct */
void
flexran_agent_read_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
s
);
void
flexran_agent_read_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
s
);
/* read the DL slice config via the RAN into a given Protocol__FlexDlSlice
* struct */
void
flexran_agent_read_slice_dl_config
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSlice
*
dl_slice
);
/* read the UL slice config via the RAN into a given Protocol__FlexUlSlice
* struct */
void
flexran_agent_read_slice_ul_config
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexUlSlice
*
ul_slice
);
/* reads content of slice over the sc_update structure, so that it can be
/* reads content of slice over the sc_update structure, so that it can be
* applied later by performing a diff between slice_config and sc_update */
* applied later by performing a diff between slice_config and sc_update */
void
prepare_update_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
slice
);
void
prepare_update_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
slice
);
/* apply generic slice parameters (e.g. intra-/interslice sharing activated or
* not) if there are changes. Returns the number of changed parameters. */
int
apply_new_slice_config
(
mid_t
mod_id
,
Protocol__FlexSliceConfig
*
olds
,
Protocol__FlexSliceConfig
*
news
);
/* apply new configuration of slice in DL if there are changes between the
* parameters. Returns the number of changed parameters. */
int
apply_new_slice_dl_config
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
oldc
,
Protocol__FlexDlSlice
*
newc
);
/* apply new configuration of slice in UL if there are changes between the
* parameters. Returns the number of changed parameters. */
int
apply_new_slice_ul_config
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
oldc
,
Protocol__FlexUlSlice
*
newc
);
/* inserts a new ue_config into the structure keeping ue to slice association
/* inserts a new ue_config into the structure keeping ue to slice association
* updates and marks so it can be applied */
* updates and marks so it can be applied */
void
prepare_ue_slice_assoc_update
(
mid_t
mod_id
,
Protocol__FlexUeConfig
*
ue_config
);
void
prepare_ue_slice_assoc_update
(
mid_t
mod_id
,
Protocol__FlexUeConfig
*
ue_config
);
...
...
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
View file @
8c76d6ab
...
@@ -28,346 +28,3 @@
...
@@ -28,346 +28,3 @@
#include "flexran_agent_mac_slice_verification.h"
#include "flexran_agent_mac_slice_verification.h"
/* overlap check for UL slices, helper type */
struct
sregion_s
{
int
start
;
int
length
;
};
/* forward declaration of locally-used verification functions */
int
flexran_dl_slice_verify_pct
(
int
pct
);
int
flexran_dl_slice_verify_priority
(
int
prio
);
int
flexran_dl_slice_verify_position
(
int
pos_low
,
int
pos_high
);
int
flexran_dl_slice_verify_maxmcs
(
int
maxmcs
);
int
flexran_ul_slice_verify_pct
(
int
pct
);
int
flexran_ul_slice_verify_priority
(
int
prio
);
int
flexran_ul_slice_verify_first_rb
(
int
first_rb
);
int
flexran_ul_slice_verify_maxmcs
(
int
maxmcs
);
int
check_ul_slice_overlap
(
mid_t
mod_id
,
struct
sregion_s
*
sr
,
int
n
);
int
flexran_verify_dl_slice
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
dls
)
{
/* check mandatory parameters */
if
(
!
dls
->
has_id
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] Incoming DL slice configuration has no ID
\n
"
,
mod_id
);
return
0
;
}
/* verify parameters individualy */
/* label is enum */
if
(
!
flexran_dl_slice_verify_pct
(
dls
->
percentage
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] illegal DL slice percentage (%d)
\n
"
,
mod_id
,
dls
->
id
,
dls
->
percentage
);
return
0
;
}
/* isolation is a protobuf bool */
if
(
!
flexran_dl_slice_verify_priority
(
dls
->
priority
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] illegal DL slice priority (%d)
\n
"
,
mod_id
,
dls
->
id
,
dls
->
priority
);
return
0
;
}
if
(
!
flexran_dl_slice_verify_position
(
dls
->
position_low
,
dls
->
position_high
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] illegal DL slice position low (%d) and/or high (%d)
\n
"
,
mod_id
,
dls
->
id
,
dls
->
position_low
,
dls
->
position_high
);
return
0
;
}
if
(
!
flexran_dl_slice_verify_maxmcs
(
dls
->
maxmcs
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] illegal DL slice max mcs %d
\n
"
,
mod_id
,
dls
->
id
,
dls
->
maxmcs
);
return
0
;
}
if
(
dls
->
n_sorting
==
0
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] no sorting in DL slice
\n
"
,
mod_id
,
dls
->
id
);
return
0
;
}
if
(
!
dls
->
sorting
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] no sorting found in DL slice
\n
"
,
mod_id
,
dls
->
id
);
return
0
;
}
/* sorting is an enum */
/* accounting is an enum */
if
(
!
dls
->
scheduler_name
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] no scheduler name found
\n
"
,
mod_id
,
dls
->
id
);
return
0
;
}
if
(
strcmp
(
dls
->
scheduler_name
,
"schedule_ue_spec"
)
!=
0
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][DL slice %d] setting the scheduler to something "
"different than schedule_ue_spec is currently not allowed
\n
"
,
mod_id
,
dls
->
id
);
return
0
;
}
return
1
;
}
int
flexran_verify_group_dl_slices
(
mid_t
mod_id
,
Protocol__FlexDlSlice
**
existing
,
int
n_ex
,
Protocol__FlexDlSlice
**
update
,
int
n_up
)
{
int
i
,
j
,
n
;
int
pct
,
pct_orig
;
/* for every update, array points to existing slice, or NULL if update
* creates new slice */
Protocol__FlexDlSlice
*
s
[
n_up
];
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
s
[
i
]
=
NULL
;
for
(
j
=
0
;
j
<
n_ex
;
j
++
)
{
if
(
existing
[
j
]
->
id
==
update
[
i
]
->
id
)
s
[
i
]
=
existing
[
j
];
}
}
/* check that number of created and number of added slices in total matches
* [1,10] */
n
=
n_ex
;
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
/* new slice */
if
(
!
s
[
i
])
n
+=
1
;
/* slice will be deleted */
else
if
(
s
[
i
]
->
percentage
==
0
)
n
-=
1
;
/* else "only" an update */
}
if
(
n
<
1
||
n
>
10
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] Illegal number of resulting DL slices (%d -> %d)
\n
"
,
mod_id
,
n_ex
,
n
);
return
0
;
}
/* check that the sum of all slices percentages (including removed/added
* slices) matches [1,100] */
pct
=
0
;
for
(
i
=
0
;
i
<
n_ex
;
i
++
)
{
pct
+=
existing
[
i
]
->
percentage
;
}
pct_orig
=
pct
;
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
/* if there is an existing slice, subtract its percentage and add the
* update's percentage */
if
(
s
[
i
])
pct
-=
s
[
i
]
->
percentage
;
pct
+=
update
[
i
]
->
percentage
;
}
if
(
pct
<
1
||
pct
>
100
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] invalid total RB share for DL slices (%d%% -> %d%%)
\n
"
,
mod_id
,
pct_orig
,
pct
);
return
0
;
}
return
1
;
}
int
flexran_verify_ul_slice
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
uls
)
{
/* check mandatory parameters */
if
(
!
uls
->
has_id
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] Incoming UL slice configuration has no ID
\n
"
,
mod_id
);
return
0
;
}
/* verify parameters individually */
/* label is enum */
if
(
!
flexran_ul_slice_verify_pct
(
uls
->
percentage
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] illegal UL slice percentage (%d)
\n
"
,
mod_id
,
uls
->
id
,
uls
->
percentage
);
return
0
;
}
/* isolation is a protobuf bool */
if
(
!
flexran_ul_slice_verify_priority
(
uls
->
priority
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] illegal UL slice percentage (%d)
\n
"
,
mod_id
,
uls
->
id
,
uls
->
priority
);
return
0
;
}
if
(
!
flexran_ul_slice_verify_first_rb
(
uls
->
first_rb
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] illegal UL slice first RB (%d)
\n
"
,
mod_id
,
uls
->
id
,
uls
->
first_rb
);
return
0
;
}
if
(
!
flexran_ul_slice_verify_maxmcs
(
uls
->
maxmcs
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] illegal UL slice max mcs (%d)
\n
"
,
mod_id
,
uls
->
id
,
uls
->
maxmcs
);
return
0
;
}
/* TODO
if (uls->n_sorting == 0) {
LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] no sorting in UL slice\n",
mod_id, uls->id);
return 0;
}
if (!uls->sorting) {
LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] no sorting found in UL slice\n",
mod_id, uls->id);
return 0;
}
*/
/* sorting is an enum */
/* accounting is an enum */
if
(
!
uls
->
scheduler_name
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] no scheduler name found
\n
"
,
mod_id
,
uls
->
id
);
return
0
;
}
if
(
strcmp
(
uls
->
scheduler_name
,
"schedule_ulsch_rnti"
)
!=
0
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d][UL slice %d] setting the scheduler to something "
"different than schedule_ulsch_rnti is currently not allowed
\n
"
,
mod_id
,
uls
->
id
);
return
0
;
}
return
1
;
}
int
flexran_verify_group_ul_slices
(
mid_t
mod_id
,
Protocol__FlexUlSlice
**
existing
,
int
n_ex
,
Protocol__FlexUlSlice
**
update
,
int
n_up
)
{
int
i
,
j
,
n
;
int
pct
,
pct_orig
;
/* for every update, array "s" points to existing slice, or NULL if update
* creates new slice; array "offs" gives the offset of this slice */
Protocol__FlexUlSlice
*
s
[
n_up
];
int
offs
[
n_up
];
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
s
[
i
]
=
NULL
;
offs
[
i
]
=
0
;
for
(
j
=
0
;
j
<
n_ex
;
j
++
)
{
if
(
existing
[
j
]
->
id
==
update
[
i
]
->
id
)
{
s
[
i
]
=
existing
[
j
];
offs
[
i
]
=
j
;
}
}
}
/* check that number of created and number of added slices in total matches
* [1,10] */
n
=
n_ex
;
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
/* new slice */
if
(
!
s
[
i
])
n
+=
1
;
/* slice will be deleted */
else
if
(
s
[
i
]
->
percentage
==
0
)
n
-=
1
;
/* else "only" an update */
}
if
(
n
<
1
||
n
>
10
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] Illegal number of resulting UL slices (%d -> %d)
\n
"
,
mod_id
,
n_ex
,
n
);
return
0
;
}
/* check that the sum of all slices percentages (including removed/added
* slices) matches [1,100] */
pct
=
0
;
for
(
i
=
0
;
i
<
n_ex
;
i
++
)
{
pct
+=
existing
[
i
]
->
percentage
;
}
pct_orig
=
pct
;
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
/* if there is an existing slice, subtract its percentage and add the
* update's percentage */
if
(
s
[
i
])
pct
-=
s
[
i
]
->
percentage
;
pct
+=
update
[
i
]
->
percentage
;
}
if
(
pct
<
1
||
pct
>
100
)
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] invalid total RB share (%d%% -> %d%%)
\n
"
,
mod_id
,
pct_orig
,
pct
);
return
0
;
}
/* check that there is no overlap in slices resulting as the combination of
* first_rb and percentage */
struct
sregion_s
sregion
[
n
];
const
int
N_RB
=
flexran_get_N_RB_UL
(
mod_id
,
0
);
/* assume PCC */
int
k
=
n_ex
;
for
(
i
=
0
;
i
<
n_ex
;
i
++
)
{
sregion
[
i
].
start
=
existing
[
i
]
->
first_rb
;
sregion
[
i
].
length
=
existing
[
i
]
->
percentage
*
N_RB
/
100
;
}
for
(
i
=
0
;
i
<
n_up
;
i
++
)
{
ptrdiff_t
d
=
s
[
i
]
?
offs
[
i
]
:
k
++
;
AssertFatal
(
d
>=
0
&&
d
<
k
,
"illegal pointer offset (%ld, k=%d)
\n
"
,
d
,
k
);
sregion
[
d
].
start
=
update
[
i
]
->
first_rb
;
sregion
[
d
].
length
=
update
[
i
]
->
percentage
*
N_RB
/
100
;
}
AssertFatal
(
k
==
n
,
"illegal number of slices while calculating overlap
\n
"
);
if
(
!
check_ul_slice_overlap
(
mod_id
,
sregion
,
k
))
{
LOG_E
(
FLEXRAN_AGENT
,
"[%d] UL slices are overlapping
\n
"
,
mod_id
);
return
0
;
}
return
1
;
}
int
flexran_dl_slice_verify_pct
(
int
pct
)
{
return
pct
>=
0
&&
pct
<=
100
;
}
int
flexran_dl_slice_verify_priority
(
int
prio
)
{
return
prio
>=
0
;
}
int
flexran_dl_slice_verify_position
(
int
pos_low
,
int
pos_high
)
{
return
pos_low
<
pos_high
&&
pos_low
>=
0
&&
pos_high
<=
N_RBG_MAX
;
}
int
flexran_dl_slice_verify_maxmcs
(
int
maxmcs
)
{
return
maxmcs
>=
0
&&
maxmcs
<=
28
;
}
int
flexran_ul_slice_verify_pct
(
int
pct
)
{
return
pct
>=
0
&&
pct
<=
100
;
}
int
flexran_ul_slice_verify_priority
(
int
prio
)
{
return
prio
>=
0
;
}
int
flexran_ul_slice_verify_first_rb
(
int
first_rb
)
{
return
first_rb
>=
0
&&
first_rb
<
100
;
}
int
flexran_ul_slice_verify_maxmcs
(
int
maxmcs
)
{
return
maxmcs
>=
0
&&
maxmcs
<=
20
;
}
int
sregion_compare
(
const
void
*
_a
,
const
void
*
_b
)
{
const
struct
sregion_s
*
a
=
(
const
struct
sregion_s
*
)
_a
;
const
struct
sregion_s
*
b
=
(
const
struct
sregion_s
*
)
_b
;
const
int
res
=
a
->
start
-
b
->
start
;
if
(
res
<
0
)
return
-
1
;
else
if
(
res
==
0
)
return
0
;
else
return
1
;
}
int
check_ul_slice_overlap
(
mid_t
mod_id
,
struct
sregion_s
*
sr
,
int
n
)
{
int
i
;
int
overlap
,
op
,
u
;
const
int
N_RB
=
flexran_get_N_RB_UL
(
mod_id
,
0
);
/* assume PCC */
qsort
(
sr
,
n
,
sizeof
(
sr
[
0
]),
sregion_compare
);
for
(
i
=
0
;
i
<
n
;
i
++
)
{
u
=
i
==
n
-
1
?
N_RB
:
sr
[
i
+
1
].
start
;
AssertFatal
(
sr
[
i
].
start
<=
u
,
"unsorted slice list
\n
"
);
overlap
=
sr
[
i
].
start
+
sr
[
i
].
length
-
u
;
if
(
overlap
<=
0
)
continue
;
op
=
overlap
*
100
/
sr
[
i
].
length
;
LOG_W
(
FLEXRAN_AGENT
,
"[%d] slice overlap of %d%% detected
\n
"
,
mod_id
,
op
);
if
(
op
>=
10
)
/* more than 10% overlap -> refuse */
return
0
;
}
return
1
;
}
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
View file @
8c76d6ab
...
@@ -29,9 +29,3 @@
...
@@ -29,9 +29,3 @@
#include "flexran_agent_common_internal.h"
#include "flexran_agent_common_internal.h"
#include "flexran_agent_mac_internal.h"
#include "flexran_agent_mac_internal.h"
int
flexran_verify_dl_slice
(
mid_t
mod_id
,
Protocol__FlexDlSlice
*
dls
);
int
flexran_verify_group_dl_slices
(
mid_t
mod_id
,
Protocol__FlexDlSlice
**
existing
,
int
n_ex
,
Protocol__FlexDlSlice
**
update
,
int
n_up
);
int
flexran_verify_ul_slice
(
mid_t
mod_id
,
Protocol__FlexUlSlice
*
uls
);
int
flexran_verify_group_ul_slices
(
mid_t
mod_id
,
Protocol__FlexUlSlice
**
existing
,
int
n_ex
,
Protocol__FlexUlSlice
**
update
,
int
n_up
);
openair2/ENB_APP/MESSAGES/V2/config_common.proto
View file @
8c76d6ab
...
@@ -61,83 +61,6 @@ enum flex_qam {
...
@@ -61,83 +61,6 @@ enum flex_qam {
//
//
// Slice config related structures and enums
// Slice config related structures and enums
//
//
enum
flex_dl_sorting
{
CR_ROUND
=
0
;
// Highest HARQ first
CR_SRB12
=
1
;
// Highest SRB1+2 first
CR_HOL
=
2
;
// Highest HOL first
CR_LC
=
3
;
// Greatest RLC buffer first
CR_CQI
=
4
;
// Highest CQI first
CR_LCP
=
5
;
// Highest LC priority first
}
enum
flex_ul_sorting
{
CRU_ROUND
=
0
;
// Highest HARQ first
CRU_BUF
=
1
;
// Highest BSR first
CRU_BTS
=
2
;
// More bytes to schedule first
CRU_MCS
=
3
;
// Highest MCS first
CRU_LCP
=
4
;
// Highest LC priority first
CRU_HOL
=
5
;
// Highest HOL first
}
enum
flex_dl_accounting_policy
{
POL_FAIR
=
0
;
POL_GREEDY
=
1
;
POL_NUM
=
2
;
}
enum
flex_ul_accounting_policy
{
POLU_FAIR
=
0
;
POLU_GREEDY
=
1
;
POLU_NUM
=
2
;
}
enum
flex_slice_label
{
xMBB
=
0
;
URLLC
=
1
;
mMTC
=
2
;
xMTC
=
3
;
Other
=
4
;
}
message
flex_dl_slice
{
optional
uint32
id
=
1
;
optional
flex_slice_label
label
=
2
;
// should be between 0 and 100
optional
uint32
percentage
=
3
;
// whether this slice should be exempted form interslice sharing
optional
bool
isolation
=
4
;
// increasing value means increasing prio
optional
uint32
priority
=
5
;
// min and max RB to use (in frequency) in the range [0, N_RBG_MAX]
optional
uint32
position_low
=
6
;
optional
uint32
position_high
=
7
;
// maximum MCS to be allowed in this slice
optional
uint32
maxmcs
=
8
;
repeated
flex_dl_sorting
sorting
=
9
;
optional
flex_dl_accounting_policy
accounting
=
10
;
optional
string
scheduler_name
=
11
;
}
message
flex_ul_slice
{
optional
uint32
id
=
1
;
optional
flex_slice_label
label
=
2
;
// should be between 0 and 100
optional
uint32
percentage
=
3
;
// whether this slice should be exempted form interslice sharing
optional
bool
isolation
=
4
;
// increasing value means increasing prio
optional
uint32
priority
=
5
;
// RB start to use (in frequency) in the range [0, N_RB_MAX]
optional
uint32
first_rb
=
6
;
// TODO RB number
//optional uint32 length_rb = 7;
// maximum MCS to be allowed in this slice
optional
uint32
maxmcs
=
8
;
repeated
flex_ul_sorting
sorting
=
9
;
optional
flex_ul_accounting_policy
accounting
=
10
;
optional
string
scheduler_name
=
11
;
}
//
//
// UE config related structures and enums
// UE config related structures and enums
...
...
openair2/ENB_APP/MESSAGES/V2/config_messages.proto
View file @
8c76d6ab
...
@@ -49,14 +49,6 @@ message flex_cell_config {
...
@@ -49,14 +49,6 @@ message flex_cell_config {
}
}
message
flex_slice_config
{
message
flex_slice_config
{
// whether remaining RBs after first intra-slice allocation will
// be allocated to UEs of the same slice
optional
bool
intraslice_share_active
=
3
;
// whether remaining RBs after slice allocation will be allocated
// to UEs of another slice. Isolated slices will be ignored.
optional
bool
interslice_share_active
=
4
;
repeated
flex_dl_slice
dl
=
1
;
repeated
flex_ul_slice
ul
=
2
;
}
}
message
flex_ue_config
{
message
flex_ue_config
{
...
...
openair2/ENB_APP/flexran_agent_common.c
View file @
8c76d6ab
...
@@ -316,25 +316,7 @@ int flexran_agent_destroy_enb_config_reply(Protocol__FlexranMessage *msg) {
...
@@ -316,25 +316,7 @@ int flexran_agent_destroy_enb_config_reply(Protocol__FlexranMessage *msg) {
}
}
if
(
reply
->
cell_config
[
i
]
->
slice_config
)
{
if
(
reply
->
cell_config
[
i
]
->
slice_config
)
{
for
(
int
j
=
0
;
j
<
reply
->
cell_config
[
i
]
->
slice_config
->
n_dl
;
++
j
)
{
/* TODO */
if
(
reply
->
cell_config
[
i
]
->
slice_config
->
dl
[
j
]
->
n_sorting
>
0
)
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
dl
[
j
]
->
sorting
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
dl
[
j
]
->
scheduler_name
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
dl
[
j
]);
}
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
dl
);
for
(
int
j
=
0
;
j
<
reply
->
cell_config
[
i
]
->
slice_config
->
n_ul
;
++
j
)
{
if
(
reply
->
cell_config
[
i
]
->
slice_config
->
ul
[
j
]
->
n_sorting
>
0
)
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
ul
[
j
]
->
sorting
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
ul
[
j
]
->
scheduler_name
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
ul
[
j
]);
}
free
(
reply
->
cell_config
[
i
]
->
slice_config
->
ul
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
);
free
(
reply
->
cell_config
[
i
]
->
slice_config
);
}
}
...
...
openair2/ENB_APP/flexran_agent_ran_api.c
View file @
8c76d6ab
...
@@ -3018,142 +3018,44 @@ int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id) {
...
@@ -3018,142 +3018,44 @@ int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id) {
return
0
;
return
0
;
}
}
void
flexran_set_ue_dl_slice_idx
(
mid_t
mod_id
,
mid_t
ue_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_ue_ul_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
)
{
int
flexran_get_ue_ul_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
0
;
return
0
;
}
}
void
flexran_set_ue_ul_slice_idx
(
mid_t
mod_id
,
mid_t
ue_id
,
int
slice_idx
)
{
/* TODO */
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_dl_slice_exists
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
0
;
}
int
flexran_create_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
int
flexran_create_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
return
-
1
;
}
}
int
flexran_find_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
/* TODO */
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
int
flexran_remove_dl_slice
(
mid_t
mod_id
,
int
slice_idx
)
{
int
flexran_remove_dl_slice
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
return
-
1
;
}
}
int
flexran_get_num_dl_slices
(
mid_t
mod_id
)
{
int
flexran_find_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
0
;
}
int
flexran_get_intraslice_sharing_active
(
mid_t
mod_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_intraslice_sharing_active
(
mid_t
mod_id
,
int
intraslice_active
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_interslice_sharing_active
(
mid_t
mod_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_interslice_sharing_active
(
mid_t
mod_id
,
int
interslice_active
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
slice_id_t
flexran_get_dl_slice_id
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_dl_slice_id
(
mid_t
mod_id
,
int
slice_idx
,
slice_id_t
slice_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_dl_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
,
int
percentage
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_isolation
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_dl_slice_isolation
(
mid_t
mod_id
,
int
slice_idx
,
int
is_isolated
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_priority
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_dl_slice_priority
(
mid_t
mod_id
,
int
slice_idx
,
int
priority
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_position_low
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_dl_slice_position_low
(
mid_t
mod_id
,
int
slice_idx
,
int
poslow
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_position_high
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
return
-
1
;
}
}
void
flexran_set_dl_slice_position_high
(
mid_t
mod_id
,
int
slice_idx
,
int
poshigh
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_dl_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
)
{
//int flexran_get_dl_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s) {
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
//}
return
-
1
;
}
void
flexran_set_dl_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
,
int
maxmcs
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_
dl_slice_sorting
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSorting
**
sorting_list
)
{
int
flexran_get_
num_dl_slices
(
mid_t
mod_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
return
0
;
}
void
flexran_set_dl_slice_sorting
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSorting
*
sorting_list
,
int
n
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
}
Protocol__FlexDlAccountingPolicy
flexran_get_dl_slice_accounting_policy
(
mid_t
mod_id
,
int
slice_idx
)
{
/* TODO */
if
(
!
mac_is_present
(
mod_id
))
return
PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR
;
void
flexran_create_ul_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
return
PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR
;
}
void
flexran_set_dl_slice_accounting_policy
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlAccountingPolicy
accounting
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
if
(
!
mac_is_present
(
mod_id
))
return
;
return
;
}
}
char
*
flexran_get_dl_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
)
{
/* TODO */
if
(
!
mac_is_present
(
mod_id
))
return
NULL
;
int
flexran_remove_ul_slice
(
mid_t
mod_id
,
int
slice_idx
)
{
return
NULL
;
}
int
flexran_set_dl_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
,
char
*
name
)
{
if
(
!
mac_is_present
(
mod_id
))
return
0
;
return
0
;
}
int
flexran_create_ul_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
return
-
1
;
}
}
...
@@ -3163,62 +3065,14 @@ int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id) {
...
@@ -3163,62 +3065,14 @@ int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id) {
return
-
1
;
return
-
1
;
}
}
int
flexran_remove_ul_slice
(
mid_t
mod_id
,
int
slice_idx
)
{
//int flexran_get_ul_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s) {
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
//}
return
-
1
;
}
int
flexran_get_num_ul_slices
(
mid_t
mod_id
)
{
int
flexran_get_num_ul_slices
(
mid_t
mod_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
0
;
return
0
;
}
}
int
flexran_ul_slice_exists
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
0
;
}
slice_id_t
flexran_get_ul_slice_id
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_ul_slice_id
(
mid_t
mod_id
,
int
slice_idx
,
slice_id_t
slice_id
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_ul_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_ul_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
,
int
percentage
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_ul_slice_first_rb
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_ul_slice_first_rb
(
mid_t
mod_id
,
int
slice_idx
,
int
first_rb
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
int
flexran_get_ul_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
-
1
;
return
-
1
;
}
void
flexran_set_ul_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
,
int
maxmcs
)
{
if
(
!
mac_is_present
(
mod_id
))
return
;
}
char
*
flexran_get_ul_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
)
{
if
(
!
mac_is_present
(
mod_id
))
return
NULL
;
return
""
;
}
int
flexran_set_ul_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
,
char
*
name
)
{
if
(
!
mac_is_present
(
mod_id
))
return
0
;
return
0
;
}
/************************** S1AP **************************/
/************************** S1AP **************************/
int
flexran_get_s1ap_mme_pending
(
mid_t
mod_id
){
int
flexran_get_s1ap_mme_pending
(
mid_t
mod_id
){
...
...
openair2/ENB_APP/flexran_agent_ran_api.h
View file @
8c76d6ab
...
@@ -659,153 +659,38 @@ uint32_t flexran_get_rrc_enb_ue_s1ap_id(mid_t mod_id, rnti_t rnti);
...
@@ -659,153 +659,38 @@ uint32_t flexran_get_rrc_enb_ue_s1ap_id(mid_t mod_id, rnti_t rnti);
/* Get the DL slice ID for a UE */
/* Get the DL slice ID for a UE */
int
flexran_get_ue_dl_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
);
int
flexran_get_ue_dl_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
);
/* Set the DL slice index(!) for a UE */
/* Set the DL slice index(!) for a UE */
void
flexran_set_ue_dl_slice_idx
(
mid_t
mod_id
,
mid_t
ue_id
,
int
slice_idx
);
//
void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
/* Get the UL slice ID for a UE */
/* Get the UL slice ID for a UE */
int
flexran_get_ue_ul_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
);
int
flexran_get_ue_ul_slice_id
(
mid_t
mod_id
,
mid_t
ue_id
);
/* Set the UL slice index(!) for a UE */
/* Set the UL slice index(!) for a UE */
void
flexran_set_ue_ul_slice_idx
(
mid_t
mod_id
,
mid_t
ue_id
,
int
slice_idx
);
//void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
/* Whether intraslice sharing is active, return boolean */
int
flexran_get_intraslice_sharing_active
(
mid_t
mod_id
);
/* Set whether intraslice sharing is active */
void
flexran_set_intraslice_sharing_active
(
mid_t
mod_id
,
int
intraslice_active
);
/*
Whether intraslice sharing is active, return boolean
*/
/*
Create slice in DL, returns the new slice index
*/
int
flexran_get_interslice_sharing_active
(
mid_t
mod
_id
);
//int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice
_id);
/*
Set whether intraslice sharing is active
*/
/*
Remove slice in DL, returns new number of slices or -1 on error
*/
void
flexran_set_interslice_sharing_active
(
mid_t
mod_id
,
int
interslice_active
);
//int flexran_remove_dl_slice(mid_t mod_id, int slice_idx
);
/* Finds slice in DL with given slice_id and returns slice index */
int
flexran_find_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
/* Return the parameters of slice at index slice_idx */
//void flexran_get_dl_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s);
/* Get the number of slices in DL */
/* Get the number of slices in DL */
int
flexran_get_num_dl_slices
(
mid_t
mod_id
);
int
flexran_get_num_dl_slices
(
mid_t
mod_id
);
/* Query slice existence in DL. Return is boolean value */
/* Create slice in UL, returns the new slice index */
int
flexran_dl_slice_exists
(
mid_t
mod_id
,
int
slice_idx
);
//int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id);
/* Remove slice in UL */
//int flexran_remove_ul_slice(mid_t mod_id, int slice_idx);
/* Create slice in DL, returns the new slice index */
int
flexran_create_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
/* Finds slice in DL with given slice_id and returns slice index */
/* Finds slice in DL with given slice_id and returns slice index */
int
flexran_find_dl_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
int
flexran_find_ul_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
/* Remove slice in DL, returns new number of slices or -1 on error */
/* Return the parameters of slice at index slice_idx */
int
flexran_remove_dl_slice
(
mid_t
mod_id
,
int
slice_idx
);
//void flexran_get_ul_slice(mid_t mod_id, int slice_idx, Protocol__FlexSlice *s);
/* Get the ID of a slice in DL */
slice_id_t
flexran_get_dl_slice_id
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the ID of a slice in DL */
void
flexran_set_dl_slice_id
(
mid_t
mod_id
,
int
slice_idx
,
slice_id_t
slice_id
);
/* Get the RB share a slice in DL, value 0-100 */
int
flexran_get_dl_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the RB share a slice in DL, value 0-100 */
void
flexran_set_dl_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
,
int
percentage
);
/* Whether a slice in DL is isolated */
int
flexran_get_dl_slice_isolation
(
mid_t
mod_id
,
int
slice_idx
);
/* Set whether a slice in DL is isolated */
void
flexran_set_dl_slice_isolation
(
mid_t
mod_id
,
int
slice_idx
,
int
is_isolated
);
/* Get the priority of a slice in DL */
int
flexran_get_dl_slice_priority
(
mid_t
mod_id
,
int
slice_idx
);
/* Get the priority of a slice in DL */
void
flexran_set_dl_slice_priority
(
mid_t
mod_id
,
int
slice_idx
,
int
priority
);
/* Get the lower end of the frequency range for the slice positioning in DL */
int
flexran_get_dl_slice_position_low
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the lower end of the frequency range for the slice positioning in DL */
void
flexran_set_dl_slice_position_low
(
mid_t
mod_id
,
int
slice_idx
,
int
poslow
);
/* Get the higher end of the frequency range for the slice positioning in DL */
int
flexran_get_dl_slice_position_high
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the higher end of the frequency range for the slice positioning in DL */
void
flexran_set_dl_slice_position_high
(
mid_t
mod_id
,
int
slice_idx
,
int
poshigh
);
/* Get the maximum MCS for slice in DL */
int
flexran_get_dl_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the maximum MCS for slice in DL */
void
flexran_set_dl_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
,
int
maxmcs
);
/* Get the sorting order of a slice in DL, return value is number of elements
* in sorting_list */
int
flexran_get_dl_slice_sorting
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSorting
**
sorting_list
);
/* Set the sorting order of a slice in DL */
void
flexran_set_dl_slice_sorting
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlSorting
*
sorting_list
,
int
n
);
/* Get the accounting policy for a slice in DL */
Protocol__FlexDlAccountingPolicy
flexran_get_dl_slice_accounting_policy
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the accounting policy for a slice in DL */
void
flexran_set_dl_slice_accounting_policy
(
mid_t
mod_id
,
int
slice_idx
,
Protocol__FlexDlAccountingPolicy
accounting
);
/* Get the scheduler name for a slice in DL */
char
*
flexran_get_dl_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the scheduler name for a slice in DL */
int
flexran_set_dl_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
,
char
*
name
);
/* Get the number of slices in UL */
/* Get the number of slices in UL */
int
flexran_get_num_ul_slices
(
mid_t
mod_id
);
int
flexran_get_num_ul_slices
(
mid_t
mod_id
);
/* Query slice existence in UL. Return is boolean value */
int
flexran_ul_slice_exists
(
mid_t
mod_id
,
int
slice_idx
);
/* Create slice in UL, returns the new slice index */
int
flexran_create_ul_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
/* Finds slice in UL with given slice_id and returns slice index */
int
flexran_find_ul_slice
(
mid_t
mod_id
,
slice_id_t
slice_id
);
/* Remove slice in UL */
int
flexran_remove_ul_slice
(
mid_t
mod_id
,
int
slice_idx
);
/* Get the ID of a slice in UL */
slice_id_t
flexran_get_ul_slice_id
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the ID of a slice in UL */
void
flexran_set_ul_slice_id
(
mid_t
mod_id
,
int
slice_idx
,
slice_id_t
slice_id
);
/* Get the RB share a slice in UL, value 0-100 */
int
flexran_get_ul_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the RB share a slice in UL, value 0-100 */
void
flexran_set_ul_slice_percentage
(
mid_t
mod_id
,
int
slice_idx
,
int
percentage
);
/* TODO Whether a slice in UL is isolated */
/*int flexran_get_ul_slice_isolation(mid_t mod_id, int slice_idx);*/
/* TODO Set whether a slice in UL is isolated */
/*void flexran_set_ul_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated);*/
/* TODO Get the priority of a slice in UL */
/*int flexran_get_ul_slice_priority(mid_t mod_id, int slice_idx);*/
/* TODO Set the priority of a slice in UL */
/*void flexran_set_ul_slice_priority(mid_t mod_id, int slice_idx, int priority);*/
/* Get the first RB for allocation in a slice in UL */
int
flexran_get_ul_slice_first_rb
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the first RB for allocation in a slice in UL */
void
flexran_set_ul_slice_first_rb
(
mid_t
mod_id
,
int
slice_idx
,
int
first_rb
);
/* TODO Get the number of RB for the allocation in a slice in UL */
/*int flexran_get_ul_slice_length_rb(mid_t mod_id, int slice_idx);*/
/* TODO Set the of number of RB for the allocation in a slice in UL */
/*void flexran_set_ul_slice_length_rb(mid_t mod_id, int slice_idx, int poshigh);*/
/* Get the maximum MCS for slice in UL */
int
flexran_get_ul_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the maximum MCS for slice in UL */
void
flexran_set_ul_slice_maxmcs
(
mid_t
mod_id
,
int
slice_idx
,
int
maxmcs
);
/* TODO Get the sorting order of a slice in UL, return value is number of elements
* in sorting_list */
/*int flexran_get_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting **sorting_list);*/
/* TODO Set the sorting order of a slice in UL */
/*void flexran_set_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting *sorting_list, int n);*/
/* TODO Get the accounting policy for a slice in UL */
/*Protocol__UlAccountingPolicy flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx);*/
/* TODO Set the accounting policy for a slice in UL */
/*void flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__UlAccountingPolicy accountin);*/
/* Get the scheduler name for a slice in UL */
char
*
flexran_get_ul_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
);
/* Set the scheduler name for a slice in UL */
int
flexran_set_ul_slice_scheduler
(
mid_t
mod_id
,
int
slice_idx
,
char
*
name
);
/************************** S1AP **************************/
/************************** S1AP **************************/
/* Get the number of MMEs to be connected */
/* Get the number of MMEs to be connected */
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a 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