Transcript 21-07-0029-00-Using the Unified Link Layer API (ULLA)

IEEE 802.21 MEDIA INDEPENDENT HANDOVER
DCN: 21-07-0029-00
Title: Using the Unified Link Layer API (ULLA) for Generic and
Open Media Access within 802.21
Date Submitted: January, 2007
Presented at IEEE 802.21 session #18
Authors or Source(s):
Tim Farnham
Mahesh Sooriyabandara
Abstract: Overview of the API framework developed within the
collaborative GOLLUM project and how it could be used
Using the Generic Open Link Layer API
for Unified Media Access within 802.21
Examples using recent 802.21 issues / suggestions
raised by contributors
Overview
• GOLLUM project overview & achievements
• Relationship between 802.21 & ULLA
• Possible ways to use ULLA in 802.21
• ULLA compatible 802.21 links & link provider
• Use of ULLA for link configure thresholds
• Use of ULLA for link configuration
• Use of ULLA for retrieving device and link
information (802.11 example)
Original Project Objectives
• To solve the complexity and interoperability
problem related to the large number of different
APIs used for accessing communication
interfaces
• To provide triggers, handles and APIs for
different smart, context sensitive and
link/network aware applications
• To solve the abstraction and extendibility
problem related to different underlying wireless
interfaces and networking technologies.
• To design, develop and in part implement a
solution to hide the embedded communication
network problem from the middleware,
application and operating system programmers.
• To develop a wireless interface description
method that can be used as a tool and as a
framework for presenting and extending the API
support for current and future wireless interfaces.
Main Project Achievements
• ULLA demonstrates that it is possible to use one
single API to get information from and control various
link layer technologies
•
possible across different platforms & operating systems
• Benefits for link-aware applications / cross-layer
design and the ULLA concept has been proven with
the demonstrators prototyped during the project
execution
• GOLLUM is an enabling technology for innovative
link enhancements and optimisation
Main Project Achievements (2)
• The technical goals have been fulfilled:
• Performance evaluated
• Inclusion of GOLLUM does not present a significant
performance ‘hit’
• A higher level of operating system integration maximises the
performance levels but this leads to a lower degree of
flexibility
• Scalability
• GOLLUM has been implemented and tested on devices
ranging from low-end sensors to high-end laptops
• Extensibility
• There is provision for future radio technologies to be
incorporated into GOLLUM without modification of the core
functionality
• Portability
• ANSI C API Definition (common across all platforms and
implementations)
• Use of Java/Javascript, C++ and C# APIs for enhanced
portability
ULLA in a nutshell (1)
Key:
Link User (Application)
Applications
Link User (Application)
ULLA Components
ULLA LU API
Notification
Requests
InfoQuery
Commands
ULLA Command
Processing
Commands
ULLA Query
Processing
UpdateRequest
Notifications
ULLA Event
Processing
Events
Legacy Drivers
ULLA Storage
GetAttribute
ULLA LP API
LL Adapter
802.11 driver
LL Adapter
Bluetooth
stack
LL Adapter
GPRS
Modem
LLA
Next generation
ULLA enabled
driver
ULLA in a nutshell (2)
•
•
•
•
ULLA LU API exposes three types of services to
applications: information querying, trigger notification
and commands
ULLA LP API allows technology specific device
drivers to be plugged in to ULLA core to expose
information in a uniform way.
Extensible ULLA data abstraction model organises
link parameters of different technologies
UQL – Use SQL syntax strings to specify query and
trigger conditions
ULLA Demonstration Platforms
• Multimedia streaming platform
• Linux user space ULLA and 802.11 LLA
• Connection management platform
• Windows CE kernel space and 802.11, GPRS and Bluetooth
LLA’s
• Real-time multimedia platform
• Linux user space on “Nomadik™” platform with STM
Phasor 802.11 LLA
• Wireless Sensor Network platform
• TinyOS Mica2 & Micaz sensors using nesC language
Multimedia Streaming Demonstrator
Platform
• Scenarios
• Dynamic Channel Selection
•
•
•
Frequency, time and other (e.g. spatial)
channels / multiplexing schemes
Avoidance of interference and network
congestion
Adaptive Transcoding
•
•
Video codec, resolution and frame rate
More rapid Adaptation of rate to link
performance variation
• Focus on
802.11 WLAN
Video
Client 1
Netperf
server 1
UDP
WLAN AP 1
Video
server
UDP
IP
Ethernet
Transcoding proxy
Router
IP
Ethernet
IP
Ethernet
UDP
IP
Ethernet
Ethernet
TCP
IP
802.11
802.11
UDP
IP
Video
Client 2
Ethernet
Netperf
server 2
UDP
WLAN AP 2
Ethernet
802.11
TCP
IP
802.11
Connection Management Demonstration
Platform
• Scenarios
• Handle and prioritize the
connection requests coming
from multiple applications
• Establish Connections on behalf
of the application, using the
“best possible” path in the
current networking environment
• Monitor the “quality” of
established connections
• Try to re-establish a new
connection when a link
disappears
• Focus on 802.11 & GPRS
Note : CeBIT 2006 demo
based on this platform
was developed by
Materna / EMIC
Real-time Multimedia Demonstration
Platform
• Scenario
• Adapt a real-time
multimedia session to
changing wireless
network conditions
• In particular to
perform codec
selection and selection
of FEC mechanisms
• Focus on Voice over IP
over WLAN
802.21 Implementation with ULLA
Applications
(Video/Audio/Web)
Connection
Management
Applications
(Video/Audio/Web etc.)
Handover
Policy
Connection
Manager
MIH ULLA
Agent
Handover Management
Link User API
ULLA
Storage
Mobility Management Protocols
L2 Triggers
and Events
WLAN
Handover
Messages
Handover
Messages
Information
Service
Information
Service
Cellular
WMAN
Protocol and Device Hardware
Request
Notification
Command
Query
ULLA
Smart
Triggers
ULLA Core
IEEE 802.21
802.21 MIH Function
L2 Triggers
and Events
Handover
command
Information
Query
LLA
LLA
WLAN
Cellular
LLA
WMAN
Protocol and Device Hardware
Derived from DCN: 21-06-0706-00-0000
ULLA & 802.21 Event/Command functions
• Handover initiation
• ullaDoCmd() - scanAvailableLinks to populate the
information about new available links
• ullaRequestNotification() - to setup triggers to be notified
when new links are available
• Network selection
• ullaRequestInfo() and ullaRequestNotification () API calls to
select a link that matches a certain criteria.
• Interface activation
• ullaDoCmd(), ullaSetAttribute() and ullaConfigureL3() API
calls - to configure the L2 and L3
ULLA and 802.21 Information Service
• 802.21 Global Network Map could be mapped to ULLA data
model
• ULLA Agents placed in network nodes
• could gather information & populate map
•
•
•
•
•
all available networks (GPRS, 802.16)
Link layer information (Neighbour maps)
Higher layer services (ISP, MMS)
could translate link information to RDF schema format
could use a push-pull type service to populate local ULLA
database gather global information available at the .21
Information server
• Possible to implement parts of 802.21 Information Service
using ULLA framework
ULLA extension for 80221 Link classes
Technology -independent
base classes
ullaLink
securityLink
Classes for families
of standards
80216Link
wsnLink
80211Link
cellularLink
btLink
80221Link
Standard-amendment
classes
80216eLink
80211kLink
hsdpaLink
btEdrLink
UMTSLink
Vendor-specific
classes
btHiddenProfileLink
channelBondingLink
newWsnMacLink
• ULLA link hierarchy
• Mandatory base class
+ optional classes
• 80221Link class can
be an optional class
supporting 80221
Example LP 1 offers
links supporting
specific attributes and
ullaLink
commands (methods)
cellularLink
• Link providers can
80221Link
support 80221
UMTSLink
together with other
technologies to
Example LP2
permit access to
ullaLink
offers links
supporting
information and link
80211Link
802.11/
802.21Links
configuration
80221Link
• 80221 link class can
channelBondingLink
provide “linkup”,
“linkgoingdown” etc.
event notification
Link Configure Thresholds –
(from 21-06-0739-00-0000-Suggestion about link parameter threshold configuration)
Name
Type
Valid Range
Description
LinkParameterList
List
N/A
A list of following set of parameters:
TrafficType,
LinkParameterThresholdList
TrafficType
INTEGER
0x00- All types
0x01conversational
0x02- streaming
0x03- interactive
0x04background
0x05-0xff:
reserved
Traffic classes for which thresholds may be set.
LinkParameterThresholdList
List
N/A
A list of following set of parameters:
LinkParameterType,
InitiateActionThreshold,
RollbackActionThreshold,
ExecuteActionThreshold
Link ParameterType
Link Quality Parameter
Type (8)
N/A
Parameters for which thresholds may be set. LinkParameterType is media specific.
InitiateActionThreshold
Link parameter
Threshold (16)
N/A
Threshold value which may cause Upper layers to start “setup” type activities in
response to actual parameter values crossing this threshold.
RollbackActionThreshold
Link parameter
Threshold (16)
N/A
Threshold value which may cause Upper layers to cancel or rollback the above
setup type operation if the actual parameter values retreat to this threshold.
ExecuteActionThreshold
Link parameter
Threshold (16)
N/A
Threshold value which may cause Upper layers to execute taking appropriate
action if the actual parameter values cross this threshold.
HO Threshold Setting using
ULLA Notification Request and (Joined Query)
•
Basic query structure
•
•
SELECT parameter FROM classes WHERE condition
Example
void HOHandler(RnId_t rnId, ullaResult_t res, void* privdata){
// do a connect on this id
int id;
CmdDescr_t cmdDescr;
if ((ullaResultNextTuple(res) == ULLA_OK) &&
(ullaResultIntValue(res, 1, &id) == ULLA_OK)) {
cmdDescr.className=“UMTSLink";
cmdDescr.cmd=“connect";
cmdDescr.id=id;
if (ullaPrepareCmd(&cmdDescr) == ULLA_OK)
ullaDoCmd(&cmdDescr, 10000);
}
}
ullaResultFree(res);
We get notified each time
the id’s of the UMTS links
change with condition :
Residual BER < 5x10-5
and Tx bit rate > 10Kbps
So we just connect to the
first link meeting the
criteria
char *query = “SELECT ieee80221Link.id FROM UMTSLink, ieee80221Link WHERE
UMTSLink.residualBER < 5E5 AND UMTSLink.txBitRate > 10000 AND
ieee80221Link.TrafficType=2”;
RnDescr_t
reqNotifDesc;
reqNotifDesc.query = (char*)query;
reqNotifDesc.count = 0;
reqNotifDesc.period = 0;
reqNotifDesc.privdata = NULL;
ullaRequestNotification(&reqNotifDesc, HOHandler, &rnId, 0);
•
•
HO Threshold & Simple Statistics within
ULLA Notification Request
Basic statistical query
• SELECT stat(parameter) FROM classes WHERE condition
Example
void HOHandler(RnId_t rnId, ullaResult_t res, void* privdata) {
char *query = “SELECT ieee80221Link.id, UMTSLink.txBitRate FROM UMTSLink, ieee80221Link WHERE
UMTSLink.residualBER < 5E5 AND UMTSLink.txBitRate > 10000 AND ieee80221Link.TrafficType=2”;
int maxbitrate, bitrate, id;
ullaResult_t result;
CmdDescr_t cmdDescr;
if ((ullaResultIntValue(res, 1, &maxbitrate) == ULLA_OK) &&
(ullaRequestInfo(query, &result, 0) == ULLA_OK)) {
while (ullaResultNextTuple(result) == ULLA_OK) {
if ((ullaResultIntValue(result, 1, &id) == ULLA_OK) &&
(ullaResultIntValue(result, 2, &bitrate) == ULLA_OK) &&
(bitrate == maxbitrate)) {
cmdDescr.className=“UMTSLink";
cmdDescr.cmd=“connect";
cmdDescr.id=id;
if (ullaPrepareCmd(&cmdDescr) == ULLA_OK)
ullaDoCmd(&cmdDescr, 10000);
}
}
}
}
break;
ullaResultFree(result);
}
ullaResultFree(res);
char *query = “SELECT MAX( UMTSLink.txBitRate ) FROM UMTSLink, ieee80221Link
WHERE UMTSLink.residualBER < 5E5 AND ieee80221Link.TrafficType=2”;
RnDescr_t
reqNotifDesc;
reqNotifDesc.query = (char*)query;
reqNotifDesc.count = 0;
reqNotifDesc.period = 0;
reqNotifDesc.privdata = NULL;
ullaRequestNotification(&reqNotifDesc, HOHandler, &rnId, 0);
We get
notified each
time the
UMTS link
with the
maximum bit
rate changes
and the
residual BER
is < 5x10-5
We connect to
this link if it is
> 10 Kbps
Setting Optional LP Measurement
Configuration for HO Threshold
void HOHandler(RnId_t rnId, ullaResult_t res, void* privdata){
// do a connect on this id
int id;
CmdDescr_t cmdDescr;
if ((ullaResultNextTuple(res) == ULLA_OK) &&
(ullaResultIntValue(res, 1, &id) == ULLA_OK)) {
cmdDescr.className=“ullaLink";
cmdDescr.cmd=“connect";
cmdDescr.id=id;
if (ullaPrepareCmd(&cmdDescr) == ULLA_OK)
ullaDoCmd(&cmdDescr, 10000);
}
}
ullaResultFree(res);
We get notified each time the id’s
of the links meeting the criteria
change - mean bit rate > 10 Kbps
Update at a rate of not more than
once every 10 seconds to avoid
ping-pong or false triggering
RnDescr_t rnDescr;
RnId_t rnId;
AttrDescr_t attrDescr;
Int val[1]
val[0] = -100;
Instructs the Link Provider to
attrDescr.id = 1;
compute the average over 100
attrDescr.className = “ullaLinkProvider”;
attrDescr.attribute = “ullaLink.txbitrate.window”;
intervals (with sliding window) to
attrDescr.qualifier = ULLA_QUAL_MEASUREMENT;
attrDescr.type = ULLA_TYPE_INT;
smooth out the bit rate values in
attrDescr.numValues = 1;
attrDescr.data = (void*)val;
dynamic environments
ullaSetAttribute (&attrDescr);
attrDescr.attribute = “ullaLink.txbitrate.interval”;
Val[0] = -10000;
Sets the samples to be
ullaSetAttribute (&attrDescr);
rnDescr.count = 0;
time based taken at 10
rnDescr.period = 0;
rnDescr.privdata = NULL;
second intervals, with
rnDescr.query = "SELECT ieee80221Link.id FROM ullaLink, ieee80221Link WHERE
ullaLink.txBitRate_mean > 10000 AND ieee80221Link.TrafficType=2 ";
updates occurring every
ullaRequestNotification(&rnDescr,notificationHandler,&rnId,0);
sample interval (i.e. 10s)
Link Configuration
(ref. LB Issue- #49: Comment 622)
Link_Configure.request
Function
This primitive is issued by MIH function to control
the behavior of a lower layer link.
Semantics of the service primitive
•Name
•Type
•Valid Range
•Description
•Configuration
Request Sets
•Set of configuration
parameters for
corresponding
interfaces
•N/A
•Containing a set of configuration
parameters. See table 18 below.
The parameters of the primitive are as follows:
Link_Configure.request (
SourceIdentifier,
DestinationIdentifier,
LinkIdentifier,
ConfigurationRequestsSets
)
•Name
•Type
•Valid Range
•Description
•NETWORK_TYPES_IN_USE
•INTEGER
•0x01
•0x02
•0x03
•0x04
•0x05
•Set the network type that
should be used for the lower
layer entity, e.g., a driver.
•OPERATION_MODE
•INTEGER
•0x00 Normal Mode
•0x01 Power Saving Mode
•0x02 Power Down
•Change the device’s power
mode
•DISABLE_TRANSMITTER
•Boolean
•N/A
•Enable/disable the
transmitter of the inter face.
•NETWORK_ID
•STRING
•N/A
•Change to the specified
network of an inter face.
•CURRENT_ADDRESS
•STRING
•N/A
•Change the current address
to the value specified
•SUSPEND_DRIVER
•Boolean
•N/A
•Suspend or resume of the
specified interface.
802.3
802.11
802.16
3GPP
3GPP2
When generated
This primitive is generated by MIHF when it
receives the MIH_Configure.request command
from the upper layer and attempt to control the
behaviors of lower layer link, for example, set
some features in the drivers.
Effect of receipt
The recipient responds with
Link_Configure.confirm primitive.
Link Configuration using ULLA
AttrDescr_t attrDescr;
int val[1];
val[0] = 1; //802.3
attrDescr.id = lpId;
attrDescr.className = “ieee80221LinkProvider”;
attrDescr.attribute = “NETWORK_TYPES_IN_USE”;
attrDescr.qualifier = ULLA_QUAL_EXACT;
attrDescr.type = ULLA_TYPE_INT;
attrDescr.numValues = 1;
attrDescr.data = (void*)val;
ullaSetAttribute (&attrDescr);
attrDescr.attribute = “OPERATION_MODE”;
Val[0] = 0; //Normal
attrDescr.numValues = 1;
ullaSetAttribute (&attrDescr);
We set the network types and
mode of operation via ULLA & LP
Information Service – 802.11device
information
• Recommended information to store in 802.21 database
(from 21-06-0761-00-000-Network-Selection-MIH-Support):
• SSPN name/realm
• SSPN roaming partners
• Interworking services by SSPN (including
emergency services)
• 802.11 AN parameters:
•
•
•
•
•
Location
Country/regulatory domain
{SSID, ESSID}
PHY types supported
802.11e QoS support
}
ULLA currently supported
Using ULLA to get 802.11 LP information
ullaResult_t result;
int valueCount = 0, deviceCount=0;
int mt[100][100], lpId[100];
char *query = “SELECT id, type FROM ieee80211LinkProvider”;
if (ullaRequestInfo(query, &result, 0) == ULLA_OK) {
while ((ullaResultNextTuple(result) == ULLA_OK) && (deviceCount < 100)) {
valueCount=0;
if (ullaResultIntValue(result, 1, &lpId[deviceCount])
== ULLA_OK) {
while ((ullaResultIntValue(result, 2, &mt[deviceCount][valueCount])
== ULLA_OK) && (valueCount < 100))
valueCount ++;
}
deviceCount++;
}
ullaResultFree(result);
}
We get the supported PHY from
ULLA media type attribute of the LP
int linkCount=0;
char ssid[100][256];
int linkId[100];
int len = 256;
We get the ssid from
ULLA networkName
attribute of the link
char query[100];
for (i=0;i<deviceCount;i++) {
sprintf( query, “SELECT id, networkName FROM ullaLink WHERE state=%d AND lpid =%d”,
ULLA_MEDIASTATE_CONNECTED, lpId[i] );
}
}
if (ullaRequestInfo(query, &result, 0) == ULLA_OK) {
while ((ullaResultNextTuple(result) == ULLA_OK) && (linkCount < 100)) {
if (ullaResultIntValue(result, 1, &linkId[linkCount])
== ULLA_OK) {
len=256;
ullaResultStringValue(result, 1, &ssid[linkCount][0], &len);
}
linkCount++;
}
ullaResultFree(result);
Issues that need to be addressed
• ULLA link class definitions
• Harmonise the link technology specific class
definitions with 802.21 requirements
• Develop a 802.21 link class
• Control of ULLA specification
• GOLLUM has finished and so the
specification has no official “owner”
• Sourceforge open source project
• Data model definitions need to be
consistently defined within standards groups
or via open source approach