diff --git a/voltha/adapters/openolt/openolt_data_model.py b/voltha/adapters/openolt/openolt_data_model.py
index f48e0d6..dca219d 100644
--- a/voltha/adapters/openolt/openolt_data_model.py
+++ b/voltha/adapters/openolt/openolt_data_model.py
@@ -15,6 +15,7 @@
 #
 import structlog
 import socket
+import voltha.core.flow_decomposer as fd
 from voltha.adapters.openolt.openolt_utils import OpenoltUtils
 from voltha.protos.device_pb2 import Port, Device
 from voltha.protos.openflow_13_pb2 import OFPPS_LIVE, OFPPF_FIBER, \
@@ -44,8 +45,7 @@
 
         self.adapter_agent.update_device(device)
 
-    def __del__(self):
-        pass
+        self.nni_intf_id = None
 
     def reconcile(self):
         assert self.logical_device_id is not None
@@ -115,12 +115,42 @@
         self.adapter_agent.update_device(self.device)
 
     def olt_oper_down(self):
-        self._disable_logical_device()
+        self.__disable_logical_device()
 
     def olt_delete(self):
         ld = self.adapter_agent.get_logical_device(self.logical_device_id)
         self.adapter_agent.delete_logical_device(ld)
 
+    def olt_port_add_update(self, intf_id, intf_type, oper):
+        if oper == "up":
+            oper_status = OperStatus.ACTIVE
+        else:
+            oper_status = OperStatus.DISCOVERED
+
+        if intf_type == "nni":
+            port_type = Port.ETHERNET_NNI
+        elif intf_type == "pon":
+            port_type = Port.PON_OLT
+
+        port_no, label = self.__add_port(intf_id, port_type, oper_status)
+
+        if intf_type == "nni":
+            self.__add_logical_port(port_no, intf_id, oper_status)
+            self.nni_intf_id = intf_id
+
+    def olt_nni_intf_id(self):
+        if self.nni_intf_id is not None:
+            return self.nni_intf_id
+
+        port_list = self.adapter_agent.get_ports(self.device.id,
+                                                 Port.ETHERNET_NNI)
+        logical_port = self.adapter_agent.get_logical_port(
+            self.logical_device_id, port_list[0].label)
+        self.nni_intf_id = self.platform.intf_id_from_nni_port_num(
+            logical_port.ofp_port.port_no)
+        self.log.debug("nni-intf-d ", nni_intf_id=self.nni_intf_id)
+        return self.nni_intf_id
+
     def onu_create(self, intf_id, onu_id, serial_number):
         onu_device = self.adapter_agent.get_child_device(
             self.device.id,
@@ -156,18 +186,18 @@
             self.device.id,
             serial_number=serial_number)
         try:
-            self.adapter_agent.delete_child_device(self.device_id,
+            self.adapter_agent.delete_child_device(self.device.id,
                                                    onu_device.id, onu_device)
         except Exception as e:
             self.log.error('adapter_agent error', error=e)
 
-        ofp_port_name = self._get_uni_ofp_port_name(onu_device)
+        ofp_port_name = self.__get_uni_ofp_port_name(onu_device)
         if ofp_port_name is None:
             self.log.exception("uni-ofp-port-not-found")
             return
 
         try:
-            self._delete_logical_port(onu_device)
+            self.__delete_logical_port(onu_device)
         except Exception as e:
             self.log.error('logical_port delete error', error=e)
         try:
@@ -215,7 +245,7 @@
             onu_device.oper_status = OperStatus.DISCOVERED
             self.adapter_agent.update_device(onu_device)
         # Set port oper state to Discovered
-        self.data_model._onu_ports_down(onu_device)
+        self.data_model.__onu_ports_down(onu_device)
 
         onu_adapter_agent.update_interface(onu_device,
                                            {'oper_state': 'down'})
@@ -258,27 +288,89 @@
         onu_adapter_agent.create_interface(onu_device,
                                            _OnuIndication(intf_id, onu_id))
 
-    def olt_port_add_update(self, intf_id, intf_type, oper):
-        if oper == "up":
-            oper_status = OperStatus.ACTIVE
+    def onu_download_tech_profile(self, intf_id, onu_id, uni_id, tp_path):
+        onu_device = self.adapter_agent.get_child_device(
+            self.device.id,
+            parent_port_no=self.platform.intf_id_to_port_no(intf_id,
+                                                            Port.PON_OLT),
+            onu_id=onu_id)
+        msg = {'proxy_address': onu_device.proxy_address,
+               'uni_id': uni_id, 'event': 'download_tech_profile',
+               'event_data': tp_path}
+
+        # Send the event message to the ONU adapter
+        self.adapter_agent.publish_inter_adapter_message(
+            onu_device.id, msg)
+
+    # #######################################################################
+    # Flow decomposer utility functions
+    #
+    # Flow related functions that are used by the OpenOLT flow decomposer.
+    # These are all prefixed with _ to denote that they will likely be removed
+    # once OpenOLT adapter transitions back to using core's flow decomposer.
+    # #######################################################################
+
+    def _flow_extract_info(self, flow, flow_direction):
+        uni_port_no = None
+        child_device_id = None
+        if flow_direction == "upstream":
+            for field in fd.get_ofb_fields(flow):
+                if field.type == fd.IN_PORT:
+                    is_uni, child_device_id = self.__is_uni_port(field.port)
+                    if is_uni:
+                        uni_port_no = field.port
+        elif flow_direction == "downstream":
+            for field in fd.get_ofb_fields(flow):
+                if field.type == fd.METADATA:
+                    uni_port = field.table_metadata & 0xFFFFFFFF
+                    is_uni, child_device_id = self.__is_uni_port(uni_port)
+                    if is_uni:
+                        uni_port_no = field.port
+
+            if uni_port_no is None:
+                for action in fd.get_actions(flow):
+                    if action.type == fd.OUTPUT:
+                        is_uni, child_device_id = \
+                            self.__is_uni_port(action.output.port)
+                        if is_uni:
+                            uni_port_no = action.output.port
+
+        if child_device_id:
+            child_device = self.adapter_agent.get_device(child_device_id)
+            pon_intf = child_device.proxy_address.channel_id
+            onu_id = child_device.proxy_address.onu_id
+            uni_id = self.platform.uni_id_from_port_num(uni_port_no) \
+                if uni_port_no is not None else None
         else:
-            oper_status = OperStatus.DISCOVERED
+            raise ValueError
 
-        if intf_type == "nni":
-            port_type = Port.ETHERNET_NNI
-        elif intf_type == "pon":
-            port_type = Port.PON_OLT
+        return pon_intf, onu_id, uni_id
 
-        port_no, label = self._add_port(intf_id, port_type, oper_status)
+    def _get_ofp_port_name(self, intf_id, onu_id, uni_id):
+        parent_port_no = self.platform.intf_id_to_port_no(intf_id,
+                                                          Port.PON_OLT)
+        child_device = self.adapter_agent.get_child_device(
+            self.device.id, parent_port_no=parent_port_no, onu_id=onu_id)
+        if child_device is None:
+            self.log.error("could-not-find-child-device",
+                           parent_port_no=intf_id, onu_id=onu_id)
+            return (None, None)
+        ports = self.adapter_agent.get_ports(child_device.id,
+                                             Port.ETHERNET_UNI)
+        logical_port = self.adapter_agent.get_logical_port(
+            self.logical_device_id, ports[uni_id].label)
+        ofp_port_name = (logical_port.ofp_port.name,
+                         logical_port.ofp_port.port_no)
+        return ofp_port_name
 
-        if intf_type == "nni":
-            self._add_logical_port(port_no, intf_id, oper_status)
-
-    # #################
+    # #######################################################################
     # Private functions
-    # #################
+    #
+    # These functions are prefixed with __ to denote that they are private
+    # to openolt_data_model and should not be called directly from the adapter.
+    # #######################################################################
 
-    def _disable_logical_device(self):
+    def __disable_logical_device(self):
         oper_state = OperStatus.UNKNOWN
         connect_state = ConnectStatus.UNREACHABLE
 
@@ -316,7 +408,7 @@
         self.device.connect_status = connect_state
         self.adapter_agent.update_device(self.device)
 
-    def _add_logical_port(self, port_no, intf_id, oper_state):
+    def __add_logical_port(self, port_no, intf_id, oper_state):
         self.log.info('adding-logical-port', port_no=port_no)
 
         label = OpenoltUtils.port_name(port_no, Port.ETHERNET_NNI)
@@ -348,7 +440,7 @@
         self.adapter_agent.add_logical_port(self.logical_device_id,
                                             logical_port)
 
-    def _delete_logical_port(self, child_device):
+    def __delete_logical_port(self, child_device):
         logical_ports = self.proxy.get('/logical_devices/{}/ports'.format(
             self.data_model.logical_device_id))
         for logical_port in logical_ports:
@@ -362,7 +454,7 @@
                     self.data_model.logical_device_id, logical_port)
                 return
 
-    def _onu_ports_down(self, onu_device):
+    def __onu_ports_down(self, onu_device):
         onu_ports = self.proxy.get('devices/{}/ports'.format(onu_device.id))
         for onu_port in onu_ports:
             self.log.debug('onu-ports-down', onu_port=onu_port)
@@ -382,7 +474,7 @@
                                onu_ports=onu_ports, onu_port_id=onu_port_id,
                                error=e)
 
-    def _add_port(self, intf_id, port_type, oper_status):
+    def __add_port(self, intf_id, port_type, oper_status):
         port_no = self.platform.intf_id_to_port_no(intf_id, port_type)
 
         label = OpenoltUtils.port_name(port_no, port_type, intf_id)
@@ -397,10 +489,22 @@
 
         return port_no, label
 
-    def _get_uni_ofp_port_name(self, child_device):
+    def __get_uni_ofp_port_name(self, child_device):
         logical_ports = self.proxy.get('/logical_devices/{}/ports'.format(
             self.data_model.logical_device_id))
         for logical_port in logical_ports:
             if logical_port.device_id == child_device.id:
                 return logical_port.ofp_port.name
         return None
+
+    def __is_uni_port(self, port_no):
+        try:
+            port = self.adapter_agent.get_logical_port(
+                self.logical_device_id, 'uni-{}'.format(port_no))
+            if port is not None:
+                return (not port.root_port), port.device_id
+            else:
+                return False, None
+        except Exception as e:
+            self.log.error("error-retrieving-port", e=e)
+            return False, None
diff --git a/voltha/adapters/openolt/openolt_device.py b/voltha/adapters/openolt/openolt_device.py
index 105db1d..da08170 100644
--- a/voltha/adapters/openolt/openolt_device.py
+++ b/voltha/adapters/openolt/openolt_device.py
@@ -158,10 +158,11 @@
                                                     self.host_and_port,
                                                     self.extra_args,
                                                     self.device_info)
-        self.flow_mgr = self.flow_mgr_class(self.adapter_agent, self.log,
-                                            self.stub, self.device_id,
+        self.flow_mgr = self.flow_mgr_class(self.log, self.stub,
+                                            self.device_id,
                                             self.data_model.logical_device_id,
-                                            self.platform, self.resource_mgr)
+                                            self.platform, self.resource_mgr,
+                                            self.data_model)
 
         self.alarm_mgr = self.alarm_mgr_class(
             self.log, self.adapter_agent, self.device_id,
@@ -548,7 +549,6 @@
             # Rebooting to reset the state
             self.reboot()
             self.data_model.olt_delete()
-            del self.data_model
         except Exception as e:
             self.log.error('Failure to delete openolt device', error=e)
             raise e
diff --git a/voltha/adapters/openolt/openolt_flow_mgr.py b/voltha/adapters/openolt/openolt_flow_mgr.py
index b15d70c..edac82a 100644
--- a/voltha/adapters/openolt/openolt_flow_mgr.py
+++ b/voltha/adapters/openolt/openolt_flow_mgr.py
@@ -71,14 +71,13 @@
 
 class OpenOltFlowMgr(object):
 
-    def __init__(self, adapter_agent, log, stub, device_id, logical_device_id,
-                 platform, resource_mgr):
-        self.adapter_agent = adapter_agent
+    def __init__(self, log, stub, device_id, logical_device_id,
+                 platform, resource_mgr, data_model):
+        self.data_model = data_model
         self.log = log
         self.stub = stub
         self.device_id = device_id
         self.logical_device_id = logical_device_id
-        self.nni_intf_id = None
         self.platform = platform
         self.logical_flows_proxy = registry('core').get_proxy(
             '/logical_devices/{}/flows'.format(self.logical_device_id))
@@ -206,51 +205,14 @@
         self.divide_and_add_flow(intf_id, onu_id, uni_id, port_no,
                                  classifier_info, action_info, flow)
 
-    def _is_uni_port(self, port_no):
-        try:
-            port = self.adapter_agent.get_logical_port(
-                self.logical_device_id, 'uni-{}'.format(port_no))
-            if port is not None:
-                return (not port.root_port), port.device_id
-            else:
-                return False, None
-        except Exception as e:
-            self.log.error("error-retrieving-port", e=e)
-            return False, None
-
     def _clear_flow_id_from_rm(self, flow, flow_id, flow_direction):
-        uni_port_no = None
-        child_device_id = None
-        if flow_direction == UPSTREAM:
-            for field in fd.get_ofb_fields(flow):
-                if field.type == fd.IN_PORT:
-                    is_uni, child_device_id = self._is_uni_port(field.port)
-                    if is_uni:
-                        uni_port_no = field.port
-        elif flow_direction == DOWNSTREAM:
-            for field in fd.get_ofb_fields(flow):
-                if field.type == fd.METADATA:
-                    uni_port = field.table_metadata & 0xFFFFFFFF
-                    is_uni, child_device_id = self._is_uni_port(uni_port)
-                    if is_uni:
-                        uni_port_no = field.port
-
-            if uni_port_no is None:
-                for action in fd.get_actions(flow):
-                    if action.type == fd.OUTPUT:
-                        is_uni, child_device_id = \
-                            self._is_uni_port(action.output.port)
-                        if is_uni:
-                            uni_port_no = action.output.port
-
-        if child_device_id:
-            child_device = self.adapter_agent.get_device(child_device_id)
-            pon_intf = child_device.proxy_address.channel_id
-            onu_id = child_device.proxy_address.onu_id
-            uni_id = self.platform.uni_id_from_port_num(uni_port_no) \
-                if uni_port_no is not None else None
-            uni_id = self.platform.uni_id_from_port_num(uni_port_no) \
-                if uni_port_no is not None else None
+        try:
+            pon_intf, onu_id, uni_id \
+                = self.data_model._flow_extract_info(flow, flow_direction)
+        except ValueError:
+            self.log.error("failure extracting pon_intf, onu_id, uni_id info \
+                           from flow")
+        else:
             flows = self.resource_mgr.get_flow_id_info(pon_intf, onu_id,
                                                        uni_id, flow_id)
             assert (isinstance(flows, list))
@@ -268,9 +230,6 @@
                         return
 
             self.resource_mgr.free_flow_id(pon_intf, onu_id, uni_id, flow_id)
-        else:
-            self.log.error("invalid-info", uni_port_no=uni_port_no,
-                           child_device_id=child_device_id)
 
     def retry_add_flow(self, flow):
         self.log.debug("retry-add-flow")
@@ -324,23 +283,6 @@
             self.log.debug('no device flow to remove for this flow (normal '
                            'for multi table flows)', flow=flow)
 
-    def _get_ofp_port_name(self, intf_id, onu_id, uni_id):
-        parent_port_no = self.platform.intf_id_to_port_no(intf_id,
-                                                          Port.PON_OLT)
-        child_device = self.adapter_agent.get_child_device(
-            self.device_id, parent_port_no=parent_port_no, onu_id=onu_id)
-        if child_device is None:
-            self.log.error("could-not-find-child-device",
-                           parent_port_no=intf_id, onu_id=onu_id)
-            return (None, None)
-        ports = self.adapter_agent.get_ports(child_device.id,
-                                             Port.ETHERNET_UNI)
-        logical_port = self.adapter_agent.get_logical_port(
-            self.logical_device_id, ports[uni_id].label)
-        ofp_port_name = (logical_port.ofp_port.name,
-                         logical_port.ofp_port.port_no)
-        return ofp_port_name
-
     def get_tp_path(self, intf_id, ofp_port_name, techprofile_id):
         return self.tech_profile[intf_id]. \
             get_tp_path(techprofile_id,
@@ -350,9 +292,8 @@
                                      ofp_port_name):
         # Remove the TP instance associated with the ONU
         if ofp_port_name is None:
-            ofp_port_name, ofp_port_no = self._get_ofp_port_name(intf_id,
-                                                                 onu_id,
-                                                                 uni_id)
+            ofp_port_name, ofp_port_no \
+                = self.data_model._get_ofp_port_name(intf_id, onu_id, uni_id)
         tp_id = self.resource_mgr.get_tech_profile_id_for_onu(intf_id, onu_id,
                                                               uni_id)
         tp_path = self.get_tp_path(intf_id, ofp_port_name, tp_id)
@@ -401,13 +342,9 @@
                         self.add_eapol_flow(intf_id, onu_id, uni_id, port_no,
                                             flow, alloc_id, gemport_id,
                                             vlan_id=vlan_id)
-                    parent_port_no = self.platform.intf_id_to_port_no(
-                        intf_id, Port.PON_OLT)
-                    onu_device = self.adapter_agent.get_child_device(
-                        self.device_id, onu_id=onu_id,
-                        parent_port_no=parent_port_no)
-                    (ofp_port_name, ofp_port_no) = self._get_ofp_port_name(
-                        intf_id, onu_id, uni_id)
+                    (ofp_port_name, ofp_port_no) \
+                        = self.data_model._get_ofp_port_name(intf_id, onu_id,
+                                                             uni_id)
                     if ofp_port_name is None:
                         self.log.error("port-name-not-found")
                         return
@@ -417,17 +354,12 @@
 
                     self.log.debug('Load-tech-profile-request-to-brcm-handler',
                                    tp_path=tp_path)
-                    msg = {'proxy_address': onu_device.proxy_address,
-                           'uni_id': uni_id, 'event': 'download_tech_profile',
-                           'event_data': tp_path}
-
-                    # Send the event message to the ONU adapter
-                    self.adapter_agent.publish_inter_adapter_message(
-                        onu_device.id, msg)
+                    self.data_model.onu_download_tech_profile(
+                        intf_id, onu_id, uni_id, tp_path)
 
                 if classifier[ETH_TYPE] == LLDP_ETH_TYPE:
                     self.log.debug('lldp flow add')
-                    nni_intf_id = self.get_nni_intf_id()
+                    nni_intf_id = self.data_model.olt_nni_intf_id()
                     self.add_lldp_flow(flow, port_no, nni_intf_id)
 
             elif PUSH_VLAN in action:
@@ -457,9 +389,8 @@
             return alloc_id, gem_port_ids
 
         try:
-            (ofp_port_name, ofp_port_no) = self._get_ofp_port_name(intf_id,
-                                                                   onu_id,
-                                                                   uni_id)
+            (ofp_port_name, ofp_port_no) \
+                = self.data_model._get_ofp_port_name(intf_id, onu_id, uni_id)
             if ofp_port_name is None:
                 self.log.error("port-name-not-found")
                 return alloc_id, gem_port_ids
@@ -588,7 +519,8 @@
             flow = openolt_pb2.Flow(
                 access_intf_id=intf_id, onu_id=onu_id, uni_id=uni_id,
                 flow_id=flow_id, flow_type=direction, alloc_id=alloc_id,
-                network_intf_id=self.get_nni_intf_id(), gemport_id=gemport_id,
+                network_intf_id=self.data_model.olt_nni_intf_id(),
+                gemport_id=gemport_id,
                 classifier=self.mk_classifier(classifier),
                 action=self.mk_action(action), priority=logical_flow.priority,
                 port_no=port_no, cookie=logical_flow.cookie)
@@ -630,7 +562,7 @@
                 onu_id=onu_id, uni_id=uni_id, flow_id=flow_id,
                 flow_type=UPSTREAM, access_intf_id=intf_id,
                 gemport_id=gemport_id, alloc_id=alloc_id,
-                network_intf_id=self.get_nni_intf_id(),
+                network_intf_id=self.data_model.olt_nni_intf_id(),
                 priority=logical_flow.priority,
                 classifier=self.mk_classifier(classifier),
                 action=self.mk_action(action),
@@ -673,7 +605,8 @@
             upstream_flow = openolt_pb2.Flow(
                 access_intf_id=intf_id, onu_id=onu_id, uni_id=uni_id,
                 flow_id=uplink_flow_id, flow_type=UPSTREAM, alloc_id=alloc_id,
-                network_intf_id=self.get_nni_intf_id(), gemport_id=gemport_id,
+                network_intf_id=self.data_model.olt_nni_intf_id(),
+                gemport_id=gemport_id,
                 classifier=self.mk_classifier(uplink_classifier),
                 action=self.mk_action(uplink_action),
                 priority=logical_flow.priority,
@@ -729,7 +662,8 @@
                 downstream_flow = openolt_pb2.Flow(
                     access_intf_id=intf_id, onu_id=onu_id, uni_id=uni_id,
                     flow_id=downlink_flow_id, flow_type=DOWNSTREAM,
-                    alloc_id=alloc_id, network_intf_id=self.get_nni_intf_id(),
+                    alloc_id=alloc_id,
+                    network_intf_id=self.data_model.olt_nni_intf_id(),
                     gemport_id=gemport_id,
                     classifier=self.mk_classifier(downlink_classifier),
                     action=self.mk_action(downlink_action),
@@ -1138,16 +1072,3 @@
         else:
             to_hash = dumps(classifier, sort_keys=True)
         return hashlib.md5(to_hash).hexdigest()[:12]
-
-    def get_nni_intf_id(self):
-        if self.nni_intf_id is not None:
-            return self.nni_intf_id
-
-        port_list = self.adapter_agent.get_ports(self.device_id,
-                                                 Port.ETHERNET_NNI)
-        logical_port = self.adapter_agent.get_logical_port(
-            self.logical_device_id, port_list[0].label)
-        self.nni_intf_id = self.platform.intf_id_from_nni_port_num(
-            logical_port.ofp_port.port_no)
-        self.log.debug("nni-intf-d ", nni_intf_id=self.nni_intf_id)
-        return self.nni_intf_id