diff --git a/src/schema/vnc_cfg.xsd b/src/schema/vnc_cfg.xsd
index ee0fa5c587d..1c5448ac33d 100644
--- a/src/schema/vnc_cfg.xsd
+++ b/src/schema/vnc_cfg.xsd
@@ -807,9 +807,6 @@ targetNamespace="http://www.contrailsystems.com/2012/VNC-CONFIG/0">
         <xsd:element name='forwarding-mode' type='ForwardingModeType'/>
         <!-- Enable or disable unicast RPF for virtual-network -->
         <xsd:element name='rpf' type='RpfModeType'/>
-        <!-- Ecmp nexthop load balance criterias -->
-        <xsd:element name='ecmp-hashing-include-fields'
-                     type='EcmpHashingIncludeFields'/>
     </xsd:all>
 </xsd:complexType>
 
@@ -833,6 +830,10 @@ targetNamespace="http://www.contrailsystems.com/2012/VNC-CONFIG/0">
 <!--#IFMAP-SEMANTICS-IDL
      Property('virtual-network-properties', 'virtual-network') -->
 
+<!-- Ecmp nexthop load balance criterias -->
+<!--#IFMAP-SEMANTICS-IDL
+     Property('ecmp-hashing-include-fields', 'virtual-network') -->
+
 <xsd:element name="provider-properties" type="ProviderDetails"/>
 <!--#IFMAP-SEMANTICS-IDL
      Property('provider-properties', 'virtual-network') -->
@@ -1054,9 +1055,6 @@ targetNamespace="http://www.contrailsystems.com/2012/VNC-CONFIG/0">
         <xsd:element name='interface-mirror'  type="InterfaceMirrorType"/>
         <xsd:element name="local-preference" type="xsd:integer"/>
         <xsd:element name="sub-interface-vlan-tag" type="xsd:integer"/>
-        <!-- Ecmp nexthop load balance criterias -->
-        <xsd:element name='ecmp-hashing-include-fields'
-                     type='EcmpHashingIncludeFields'/>
     </xsd:all>
 </xsd:complexType>
 
@@ -1077,6 +1075,10 @@ targetNamespace="http://www.contrailsystems.com/2012/VNC-CONFIG/0">
     </xsd:all>
 </xsd:complexType>
 
+<!-- Ecmp nexthop load balance criterias -->
+<!--#IFMAP-SEMANTICS-IDL
+     Property('ecmp-hashing-include-fields', 'virtual-machine-interface') -->
+
 <xsd:element name="virtual-machine-interface-properties" 
              type="VirtualMachineInterfacePropertiesType"/>
 <!--#IFMAP-SEMANTICS-IDL
diff --git a/src/vnsw/agent/controller/controller_export.cc b/src/vnsw/agent/controller/controller_export.cc
index fbb90ab9f96..13e661570a1 100644
--- a/src/vnsw/agent/controller/controller_export.cc
+++ b/src/vnsw/agent/controller/controller_export.cc
@@ -5,6 +5,7 @@
 #include <boost/uuid/uuid_io.hpp>
 
 #include <cmn/agent_cmn.h>
+#include <oper/ecmp_load_balance.h>
 #include <oper/route_common.h>
 #include <oper/peer.h>
 #include <oper/nexthop.h>
@@ -22,7 +23,7 @@ RouteExport::State::State() :
     DBState(), exported_(false), fabric_multicast_exported_(false),
     force_chg_(false), label_(MplsTable::kInvalidLabel), vn_(), sg_list_(),
     tunnel_type_(TunnelType::INVALID), path_preference_(),
-    destination_(), source_() {
+    destination_(), source_(), ecmp_load_balance_() {
 }
 
 bool RouteExport::State::Changed(const AgentRoute *route, const AgentPath *path) const {
@@ -51,6 +52,9 @@ bool RouteExport::State::Changed(const AgentRoute *route, const AgentPath *path)
     if (path_preference_ != path->path_preference())
         return true;
 
+    if(ecmp_load_balance_ != path->ecmp_load_balance())
+        return true;
+
     return false;
 }
 
@@ -62,6 +66,7 @@ void RouteExport::State::Update(const AgentRoute *route, const AgentPath *path)
     communities_ = path->communities();
     tunnel_type_ = path->tunnel_type();
     path_preference_ = path->path_preference();
+    ecmp_load_balance_ = path->ecmp_load_balance();
 }
 
 RouteExport::RouteExport(AgentRouteTable *rt_table):
@@ -180,7 +185,8 @@ void RouteExport::UnicastNotify(AgentXmppChannel *bgp_xmpp_peer,
                         path->NexthopIp(table->agent()), vn_list,
                         state->label_, path->GetTunnelBmap(),
                         &path->sg_list(), &path->communities(),
-                        type, state->path_preference_);
+                        type, state->path_preference_,
+                        state->ecmp_load_balance_);
         }
     } else {
         if (state->exported_ == true) {
diff --git a/src/vnsw/agent/controller/controller_export.h b/src/vnsw/agent/controller/controller_export.h
index 02c37968b5a..542655130af 100644
--- a/src/vnsw/agent/controller/controller_export.h
+++ b/src/vnsw/agent/controller/controller_export.h
@@ -12,6 +12,7 @@
 #include <oper/agent_path.h>
 
 class AgentPath;
+class EcmpLoadBalance;
 
 class RouteExport {
 public:
@@ -32,6 +33,7 @@ class RouteExport {
         //destination and source are valid for tunnel NH.
         std::string destination_;
         std::string source_;
+        EcmpLoadBalance ecmp_load_balance_;
 
         bool Changed(const AgentRoute *route, const AgentPath *path) const;
         void Update(const AgentRoute *route, const AgentPath *path);
diff --git a/src/vnsw/agent/controller/controller_peer.cc b/src/vnsw/agent/controller/controller_peer.cc
index b18a2a7f6ef..056ad382b7f 100644
--- a/src/vnsw/agent/controller/controller_peer.cc
+++ b/src/vnsw/agent/controller/controller_peer.cc
@@ -22,6 +22,7 @@
 #include "oper/peer.h"
 #include "oper/vxlan.h"
 #include "oper/agent_path.h"
+#include "oper/ecmp_load_balance.h"
 #include "cmn/agent_stats.h"
 #include <pugixml/pugixml.hpp>
 #include "xml/xml_pugi.h"
@@ -604,9 +605,45 @@ void AgentXmppChannel::ReceiveV4V6Update(XmlPugi *pugi) {
     }
 }
 
+static void GetEcmpHashFieldsToUse(ItemType *item,
+                                   EcmpLoadBalance &ecmp_load_balance) {
+    if (item->entry.load_balance.load_balance_decision.empty() ||
+        item->entry.load_balance.load_balance_decision !=
+            LoadBalanceDecision)
+        ecmp_load_balance.SetAll();
+
+    uint8_t field_list_size =  item->entry.
+        load_balance.load_balance_fields.load_balance_field_list.size();
+    if (field_list_size == 0)
+        ecmp_load_balance.SetAll();
+
+    for (uint32_t i = 0; i < field_list_size; i++) {
+        std::string field_type = item->entry.
+            load_balance.load_balance_fields.load_balance_field_list[i];
+        if (field_type == ecmp_load_balance.source_mac_str())
+            ecmp_load_balance.set_source_mac();
+        if (field_type == ecmp_load_balance.destination_mac_str())
+            ecmp_load_balance.set_destination_mac();
+        if (field_type == ecmp_load_balance.source_ip_str())
+            ecmp_load_balance.set_source_ip();
+        if (field_type == ecmp_load_balance.destination_ip_str())
+            ecmp_load_balance.set_destination_ip();
+        if (field_type == ecmp_load_balance.ip_protocol_str())
+            ecmp_load_balance.set_ip_protocol();
+        if (field_type == ecmp_load_balance.source_port_str())
+            ecmp_load_balance.set_source_port();
+        if (field_type == ecmp_load_balance.destination_port_str())
+            ecmp_load_balance.set_destination_port();
+    }
+}
+
 void AgentXmppChannel::AddEcmpRoute(string vrf_name, IpAddress prefix_addr,
                                     uint32_t prefix_len, ItemType *item,
                                     const VnListType &vn_list) {
+    //Extract the load balancer fields.
+    EcmpLoadBalance ecmp_load_balance;
+    GetEcmpHashFieldsToUse(item, ecmp_load_balance);
+
     PathPreference::Preference preference = PathPreference::LOW;
     TunnelType::TypeBmap encap = TunnelType::MplsType(); //default
     if (item->entry.local_preference == PathPreference::HIGH) {
@@ -690,7 +727,7 @@ void AgentXmppChannel::AddEcmpRoute(string vrf_name, IpAddress prefix_addr,
         new ControllerEcmpRoute(bgp_peer_id(), prefix_addr, prefix_len,
                                 vn_list, -1, false, vrf_name,
                                 item->entry.security_group_list.security_group,
-                                rp, encap, nh_req);
+                                rp, encap, ecmp_load_balance, nh_req);
 
     //ECMP create component NH
     rt_table->AddRemoteVmRouteReq(bgp_peer_id(), vrf_name,
@@ -902,6 +939,8 @@ void AgentXmppChannel::AddEvpnRoute(const std::string &vrf_name,
     ControllerLocalVmRoute *local_vm_route = NULL;
     VnListType vn_list;
     vn_list.insert(item->entry.virtual_network);
+    EcmpLoadBalance ecmp_load_balance;
+
     if (encap == TunnelType::VxlanType()) {
         local_vm_route =
             new ControllerLocalVmRoute(intf_key,
@@ -910,6 +949,7 @@ void AgentXmppChannel::AddEvpnRoute(const std::string &vrf_name,
                                        InterfaceNHFlags::BRIDGE,
                                        sg_list, path_preference,
                                        unicast_sequence_number(),
+                                       ecmp_load_balance,
                                        this);
     } else {
         local_vm_route =
@@ -920,6 +960,7 @@ void AgentXmppChannel::AddEvpnRoute(const std::string &vrf_name,
                                        InterfaceNHFlags::BRIDGE,
                                        sg_list, path_preference,
                                        unicast_sequence_number(),
+                                       ecmp_load_balance,
                                        this);
     }
     rt_table->AddLocalVmRouteReq(bgp_peer_id(), vrf_name, mac,
@@ -990,6 +1031,7 @@ void AgentXmppChannel::AddRemoteRoute(string vrf_name, IpAddress prefix_addr,
 
             VmInterfaceKey intf_key(AgentKey::ADD_DEL_CHANGE,
                                     intf_nh->GetIfUuid(), "");
+            EcmpLoadBalance ecmp_load_balance;
             BgpPeer *bgp_peer = bgp_peer_id();
             if (interface->type() == Interface::VM_INTERFACE) {
                 ControllerLocalVmRoute *local_vm_route =
@@ -1000,6 +1042,7 @@ void AgentXmppChannel::AddRemoteRoute(string vrf_name, IpAddress prefix_addr,
                                                item->entry.security_group_list.security_group,
                                                path_preference,
                                                unicast_sequence_number(),
+                                               ecmp_load_balance,
                                                this);
                 rt_table->AddLocalVmRouteReq(bgp_peer, vrf_name,
                                              prefix_addr, prefix_len,
@@ -1750,6 +1793,17 @@ bool AgentXmppChannel::ControllerSendSubscribe(AgentXmppChannel *peer,
     return true;
 }
 
+void PopulateEcmpHashFieldsToUse(ItemType &item,
+                                 const EcmpLoadBalance &ecmp_load_balance) {
+    item.entry.load_balance.load_balance_decision = LoadBalanceDecision;
+
+    if (ecmp_load_balance.AllSet())
+        return;
+
+    ecmp_load_balance.GetStringVector(
+        item.entry.load_balance.load_balance_fields.load_balance_field_list);
+}
+
 bool AgentXmppChannel::ControllerSendV4V6UnicastRouteCommon(AgentRoute *route,
                                        const VnListType &vn_list,
                                        const SecurityGroupList *sg_list,
@@ -1758,7 +1812,8 @@ bool AgentXmppChannel::ControllerSendV4V6UnicastRouteCommon(AgentRoute *route,
                                        TunnelType::TypeBmap bmap,
                                        const PathPreference &path_preference,
                                        bool associate,
-                                       Agent::RouteTableType type) {
+                                       Agent::RouteTableType type,
+                                       const EcmpLoadBalance &ecmp_load_balance) {
 
     static int id = 0;
     ItemType item;
@@ -1781,6 +1836,7 @@ bool AgentXmppChannel::ControllerSendV4V6UnicastRouteCommon(AgentRoute *route,
 
     string rtr(agent_->router_id().to_string());
 
+    PopulateEcmpHashFieldsToUse(item, ecmp_load_balance);
     autogen::NextHopType nh;
     nh.af = BgpAf::IPv4;
     nh.address = rtr;
@@ -2412,8 +2468,8 @@ bool AgentXmppChannel::ControllerSendRouteAdd(AgentXmppChannel *peer,
                                               const SecurityGroupList *sg_list,
                                               const CommunityList *communities,
                                               Agent::RouteTableType type,
-                                              const PathPreference
-                                              &path_preference)
+                                              const PathPreference &path_preference,
+                                              const EcmpLoadBalance &ecmp_load_balance)
 {
     if (!peer) return false;
 
@@ -2428,7 +2484,7 @@ bool AgentXmppChannel::ControllerSendRouteAdd(AgentXmppChannel *peer,
         ret = peer->ControllerSendV4V6UnicastRouteCommon(route, vn_list,
                                                    sg_list, communities, label,
                                                    bmap, path_preference, true,
-                                                   type);
+                                                   type, ecmp_load_balance);
     }
     if (type == Agent::EVPN) {
         std::string vn = *vn_list.begin();
@@ -2461,13 +2517,15 @@ bool AgentXmppChannel::ControllerSendRouteDelete(AgentXmppChannel *peer,
     bool ret = false;
     if (((type == Agent::INET4_UNICAST) || (type == Agent::INET6_UNICAST)) &&
          (peer->agent()->simulate_evpn_tor() == false)) {
+        EcmpLoadBalance ecmp_load_balance;
         ret = peer->ControllerSendV4V6UnicastRouteCommon(route, vn_list,
                                                        sg_list, communities,
                                                        label,
                                                        bmap,
                                                        path_preference,
                                                        false,
-                                                       type);
+                                                       type,
+                                                       ecmp_load_balance);
     }
     if (type == Agent::EVPN) {
         Ip4Address nh_ip(0);
diff --git a/src/vnsw/agent/controller/controller_peer.h b/src/vnsw/agent/controller/controller_peer.h
index f71c5e462a0..1e6539095bc 100644
--- a/src/vnsw/agent/controller/controller_peer.h
+++ b/src/vnsw/agent/controller/controller_peer.h
@@ -24,6 +24,7 @@ class VrfEntry;
 class XmlPugi;
 class PathPreference;
 class AgentPath;
+class EcmpLoadBalance;
 
 class AgentXmppChannel {
 public:
@@ -73,7 +74,8 @@ class AgentXmppChannel {
                                        const SecurityGroupList *sg_list,
                                        const CommunityList *communities,
                                        Agent::RouteTableType type,
-                                       const PathPreference &path_preference);
+                                       const PathPreference &path_preference,
+                                       const EcmpLoadBalance &ecmp_load_balance);
     static bool ControllerSendEvpnRouteAdd(AgentXmppChannel *peer,
                                            AgentRoute *route,
                                            const Ip4Address *nexthop_ip,
@@ -189,7 +191,8 @@ class AgentXmppChannel {
                                             uint32_t tunnel_bmap,
                                             const PathPreference &path_preference,
                                             bool associate,
-                                            Agent::RouteTableType type);
+                                            Agent::RouteTableType type,
+                                            const EcmpLoadBalance &ecmp_load_balance);
     bool BuildTorMulticastMessage(autogen::EnetItemType &item,
                                   std::stringstream &node_id,
                                   AgentRoute *route,
diff --git a/src/vnsw/agent/controller/controller_route_path.cc b/src/vnsw/agent/controller/controller_route_path.cc
index f50b5ac84c0..88bb6647846 100644
--- a/src/vnsw/agent/controller/controller_route_path.cc
+++ b/src/vnsw/agent/controller/controller_route_path.cc
@@ -9,6 +9,7 @@
 #include <route/route.h>
 
 #include <cmn/agent_cmn.h>
+#include <oper/ecmp_load_balance.h>
 #include <oper/route_common.h>
 #include <oper/vrf.h>
 #include <oper/tunnel_nh.h>
@@ -72,6 +73,7 @@ bool ControllerEcmpRoute::AddChangePath(Agent *agent, AgentPath *path,
                                                  vrf_name_, sg_list_,
                                                  path_preference_,
                                                  tunnel_bmap_,
+                                                 ecmp_load_balance_,
                                                  nh_req_, agent, path);
 }
 
@@ -249,10 +251,11 @@ ControllerLocalVmRoute::ControllerLocalVmRoute(const VmInterfaceKey &intf,
                                                const SecurityGroupList &sg_list,
                                                const PathPreference &path_preference,
                                                uint64_t sequence_number,
+                                               const EcmpLoadBalance &ecmp_load_balance,
                                                const AgentXmppChannel *channel) :
     LocalVmRoute(intf, mpls_label, vxlan_id, force_policy, vn_list, flags, sg_list,
                  CommunityList(),
-                 path_preference, Ip4Address(0)),
+                 path_preference, Ip4Address(0), ecmp_load_balance),
     sequence_number_(sequence_number), channel_(channel) { }
 
 bool ControllerLocalVmRoute::IsPeerValid(const AgentRouteKey *key) const {
diff --git a/src/vnsw/agent/controller/controller_route_path.h b/src/vnsw/agent/controller/controller_route_path.h
index 7fcb31668e8..a69c5676a59 100644
--- a/src/vnsw/agent/controller/controller_route_path.h
+++ b/src/vnsw/agent/controller/controller_route_path.h
@@ -12,6 +12,7 @@
 //Forward declaration
 class AgentXmppChannel;
 class AgentRouteData;
+class EcmpLoadBalance;
 class Peer;
 class BgpPeer;
 class TunnelNHKey;
@@ -127,11 +128,13 @@ class ControllerEcmpRoute : public ControllerPeerPath {
                         const string &vrf_name, SecurityGroupList sg_list,
                         const PathPreference &path_preference,
                         TunnelType::TypeBmap tunnel_bmap,
+                        const EcmpLoadBalance &ecmp_load_balance,
                         DBRequest &nh_req) :
         ControllerPeerPath(peer), dest_addr_(dest_addr), plen_(plen),
         vn_list_(vn_list), label_(label), local_ecmp_nh_(local_ecmp_nh),
         vrf_name_(vrf_name), sg_list_(sg_list),
-        path_preference_(path_preference), tunnel_bmap_(tunnel_bmap)
+        path_preference_(path_preference), tunnel_bmap_(tunnel_bmap),
+        ecmp_load_balance_(ecmp_load_balance)
         {nh_req_.Swap(&nh_req);}
 
     virtual ~ControllerEcmpRoute() { }
@@ -150,6 +153,7 @@ class ControllerEcmpRoute : public ControllerPeerPath {
     SecurityGroupList sg_list_;
     PathPreference path_preference_;
     TunnelType::TypeBmap tunnel_bmap_;
+    EcmpLoadBalance ecmp_load_balance_;
     DBRequest nh_req_;
     DISALLOW_COPY_AND_ASSIGN(ControllerEcmpRoute);
 };
@@ -167,6 +171,7 @@ class ControllerLocalVmRoute : public LocalVmRoute {
                            const SecurityGroupList &sg_list,
                            const PathPreference &path_preference,
                            uint64_t sequence_number,
+                           const EcmpLoadBalance &ecmp_load_balance,
                            const AgentXmppChannel *channel);
     virtual ~ControllerLocalVmRoute() { }
     virtual bool IsPeerValid(const AgentRouteKey *key) const;
diff --git a/src/vnsw/agent/openstack/instance_service_server.cc b/src/vnsw/agent/openstack/instance_service_server.cc
index 5049bcb2f97..44c3a943d8f 100644
--- a/src/vnsw/agent/openstack/instance_service_server.cc
+++ b/src/vnsw/agent/openstack/instance_service_server.cc
@@ -26,6 +26,7 @@
 #include <oper/vm.h>
 #include <oper/vn.h>
 #include <oper/mirror_table.h>
+#include <oper/ecmp_load_balance.h>
 #include <cfg/cfg_types.h>
 #include <openstack/instance_service_server.h>
 #include <base/contrail_ports.h>
@@ -422,11 +423,13 @@ InstanceServiceAsyncHandler::AddLocalVmRoute(const std::string& ip_address,
 
     VnListType vn_list;
     vn_list.insert("instance-service");
+    EcmpLoadBalance ecmp_load_balance;
     agent_->fabric_inet4_unicast_table()->
         AddLocalVmRouteReq(novaPeer_.get(), vrf, ip.to_v4(), 32, intf_uuid, 
                            vn_list, mpls_label, SecurityGroupList(),
                            CommunityList(),
-                           false, PathPreference(), Ip4Address(0));
+                           false, PathPreference(), Ip4Address(0),
+                           ecmp_load_balance);
     return true;
 }
 
diff --git a/src/vnsw/agent/oper/agent.sandesh b/src/vnsw/agent/oper/agent.sandesh
index 7fdcc49d977..f0d63320374 100644
--- a/src/vnsw/agent/oper/agent.sandesh
+++ b/src/vnsw/agent/oper/agent.sandesh
@@ -255,7 +255,7 @@ struct PathSandeshData {
     2: i32 label;                     // mpls label
     3: i32 vxlan_id;                // VN ID/VXLAN
     4: string peer;                   // peer originating the path 
-   20: list<string> dest_vn_list (link="VnListReq"); // destination VN list
+    5: list<string> dest_vn_list (link="VnListReq"); // destination VN list
     6: string unresolved;             // true or false
     7: optional string gw_ip;         // GW IP
     8: optional string vrf (link="VrfListReq"); // Vrf
@@ -269,6 +269,7 @@ struct PathSandeshData {
    17: optional string flood_dhcp;
    18: optional string vm_name;
    19: optional bool ecmp_suppressed;
+   20: optional string ecmp_hashing_fields;
 }
 
 struct RouteUcSandeshData {
diff --git a/src/vnsw/agent/oper/agent_path.cc b/src/vnsw/agent/oper/agent_path.cc
index 6bd521f541f..1b4f97b4115 100644
--- a/src/vnsw/agent/oper/agent_path.cc
+++ b/src/vnsw/agent/oper/agent_path.cc
@@ -24,6 +24,7 @@
 #include <oper/vxlan.h>
 #include <oper/mpls.h>
 #include <oper/route_common.h>
+#include <oper/ecmp_load_balance.h>
 #include <oper/agent_sandesh.h>
 using namespace std;
 using namespace boost::asio;
@@ -719,6 +720,12 @@ bool LocalVmRoute::AddChangePath(Agent *agent, AgentPath *path,
 
     path->set_unresolved(false);
     path->SyncRoute(sync_route_);
+
+    if (ecmp_load_balance_ != path->ecmp_load_balance()) {
+        path->set_ecmp_load_balance(ecmp_load_balance_);
+        ret = true;
+    }
+
     if (path->ChangeNH(agent, nh) == true)
         ret = true;
 
@@ -1207,6 +1214,17 @@ void AgentPath::SetSandeshData(PathSandeshData &pdata) const {
         pdata.set_flood_dhcp(dhcp_path->flood_dhcp() ? "true" : "false");
         pdata.set_vm_name(dhcp_path->vm_interface()->ToString());
     }
+    std::vector<std::string> string_vector;
+    ecmp_load_balance_.GetStringVector(string_vector);
+    std::vector<std::string>::iterator string_vector_iter =
+        string_vector.begin();
+    std::stringstream ss;
+    while (string_vector_iter != string_vector.end()) {
+        ss << (*string_vector_iter);
+        ss << ",";
+        string_vector_iter++;
+    }
+    pdata.set_ecmp_hashing_fields(ss.str());
 }
 
 void AgentPath::set_local_ecmp_mpls_label(MplsLabel *mpls) {
diff --git a/src/vnsw/agent/oper/agent_path.h b/src/vnsw/agent/oper/agent_path.h
index e6722f4ec17..c0cb1228fd7 100644
--- a/src/vnsw/agent/oper/agent_path.h
+++ b/src/vnsw/agent/oper/agent_path.h
@@ -19,6 +19,7 @@ class InterfaceKey;
 class PhysicalInterface;
 class Peer;
 class EvpnPeer;
+class EcmpLoadBalance;
 
 class PathPreference {
 public:
@@ -267,6 +268,12 @@ class AgentPath : public Path {
     const IpAddress& GetFixedIp() const {
         return path_preference_.dependent_ip();
     }
+    const EcmpLoadBalance &ecmp_load_balance() const {
+        return ecmp_load_balance_;
+    }
+    void set_ecmp_load_balance(const EcmpLoadBalance &ecmp_load_balance) {
+        ecmp_load_balance_ = ecmp_load_balance;
+    }
 
 private:
     const Peer *peer_;
@@ -333,6 +340,7 @@ class AgentPath : public Path {
     // set true if path was supposed to be ecmp, however ecmp was suppressed
     // by taking only one of the nexthop from the path
     bool ecmp_suppressed_;
+    EcmpLoadBalance ecmp_load_balance_;
     DISALLOW_COPY_AND_ASSIGN(AgentPath);
 };
 
@@ -438,13 +446,16 @@ class LocalVmRoute : public AgentRouteData {
                  uint8_t flags, const SecurityGroupList &sg_list,
                  const CommunityList &communities,
                  const PathPreference &path_preference,
-                 const IpAddress &subnet_service_ip) :
+                 const IpAddress &subnet_service_ip,
+                 const EcmpLoadBalance &ecmp_load_balance) :
         AgentRouteData(false), intf_(intf), mpls_label_(mpls_label),
         vxlan_id_(vxlan_id), force_policy_(force_policy),
         dest_vn_list_(vn_list), proxy_arp_(false), sync_route_(false),
         flags_(flags), sg_list_(sg_list), communities_(communities),
         tunnel_bmap_(TunnelType::MplsType()),
-        path_preference_(path_preference), subnet_service_ip_(subnet_service_ip) {
+        path_preference_(path_preference),
+        subnet_service_ip_(subnet_service_ip),
+        ecmp_load_balance_(ecmp_load_balance) {
     }
     virtual ~LocalVmRoute() { }
     void DisableProxyArp() {proxy_arp_ = false;}
@@ -476,6 +487,7 @@ class LocalVmRoute : public AgentRouteData {
     TunnelType::TypeBmap tunnel_bmap_;
     PathPreference path_preference_;
     IpAddress subnet_service_ip_;
+    EcmpLoadBalance ecmp_load_balance_;
     DISALLOW_COPY_AND_ASSIGN(LocalVmRoute);
 };
 
diff --git a/src/vnsw/agent/oper/ecmp_load_balance.h b/src/vnsw/agent/oper/ecmp_load_balance.h
new file mode 100644
index 00000000000..73bb79c32ec
--- /dev/null
+++ b/src/vnsw/agent/oper/ecmp_load_balance.h
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
+ */
+
+#ifndef vnsw_agent_ecmp_load_balance_hpp
+#define vnsw_agent_ecmp_load_balance_hpp
+
+#include <vnc_cfg_types.h>
+
+using namespace boost::uuids;
+using namespace std;
+
+namespace autogen {
+    struct EcmpHashingIncludeFields;
+}
+
+static const std::string HashingFieldsStr[] = {
+    "l2-source-address",
+    "l2-destination-address",
+    "l3-source-address",
+    "l3-destination-address",
+    "l4-protocol",
+    "l4-source-port",
+    "l4-destination-port"
+};
+static const std::string LoadBalanceDecision = "field-hash";
+
+class EcmpLoadBalance {
+public:
+    enum kHashingFields {
+        SOURCE_MAC,
+        DESTINATION_MAC,
+        SOURCE_IP,
+        DESTINATION_IP,
+        IP_PROTOCOL,
+        SOURCE_PORT,
+        DESTINATION_PORT,
+        NUM_HASH_FIELDS
+    };
+
+    EcmpLoadBalance() {
+        SetAll();
+    }
+    virtual ~EcmpLoadBalance() { }
+    
+    const std::string &source_mac_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::SOURCE_MAC];
+    }
+    const std::string &destination_mac_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::DESTINATION_MAC];
+    }
+    const std::string &source_ip_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::SOURCE_IP];
+    }
+    const std::string &destination_ip_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::DESTINATION_IP];
+    }
+    const std::string &source_port_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::SOURCE_PORT];
+    }
+    const std::string &destination_port_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::DESTINATION_PORT];
+    }
+    const std::string &ip_protocol_str() const {
+        return HashingFieldsStr[(uint8_t)EcmpLoadBalance::IP_PROTOCOL];
+    }
+
+    void GetStringVector (std::vector<std::string> &string_vector) const {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            if (hash_fields_to_use_[field_type])
+                string_vector.push_back(HashingFieldsStr[field_type]);
+        }
+    }
+
+    bool operator!=(const EcmpLoadBalance &rhs) const {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            if (hash_fields_to_use_[field_type] !=
+                rhs.hash_fields_to_use_[field_type])
+                return true;
+        }
+        return false;
+    }
+
+    void Copy(const EcmpLoadBalance &rhs) {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            hash_fields_to_use_[field_type] =
+                rhs.hash_fields_to_use_[field_type];
+        }
+    }
+
+    void SetAll() {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            hash_fields_to_use_[field_type] = true;
+        }
+    }
+
+    bool AllSet() const {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            if (hash_fields_to_use_[field_type] == false)
+                return false;
+        }
+        return true;
+    }
+
+    void set_source_mac() {
+        hash_fields_to_use_[SOURCE_MAC] = true;
+    }
+    void reset_source_mac() {
+        hash_fields_to_use_[SOURCE_MAC] = false;
+    }
+    void set_destination_mac() {
+        hash_fields_to_use_[DESTINATION_MAC] = true;
+    }
+    void reset_destination_mac() {
+        hash_fields_to_use_[DESTINATION_MAC] = false;
+    }
+    void set_source_ip() {
+        hash_fields_to_use_[SOURCE_IP] = true;
+    }
+    void reset_source_ip() {
+        hash_fields_to_use_[SOURCE_IP] = false;
+    }
+    void set_destination_ip() {
+        hash_fields_to_use_[DESTINATION_IP] = true;
+    }
+    void reset_destination_ip() {
+        hash_fields_to_use_[DESTINATION_IP] = false;
+    }
+    void set_ip_protocol() {
+        hash_fields_to_use_[IP_PROTOCOL] = true;
+    }
+    void reset_ip_protocol() {
+        hash_fields_to_use_[IP_PROTOCOL] = false;
+    }
+    void set_source_port() {
+        hash_fields_to_use_[SOURCE_PORT] = true;
+    }
+    void reset_source_port() {
+        hash_fields_to_use_[SOURCE_PORT] = false;
+    }
+    void set_destination_port() {
+        hash_fields_to_use_[DESTINATION_PORT] = true;
+    }
+    void reset_destination_port() {
+        hash_fields_to_use_[DESTINATION_PORT] = false;
+    }
+
+    bool is_source_mac_set() const {
+        return (hash_fields_to_use_[SOURCE_MAC]);
+    }
+    bool is_destination_mac_set() const {
+        return (hash_fields_to_use_[DESTINATION_MAC]);
+    }
+    bool is_source_ip_set() const {
+        return (hash_fields_to_use_[SOURCE_IP]);
+    }
+    bool is_destination_ip_set() const {
+        return (hash_fields_to_use_[DESTINATION_IP]);
+    }
+    bool is_source_port_set() const {
+        return (hash_fields_to_use_[SOURCE_PORT]);
+    }
+    bool is_destination_port_set() const {
+        return (hash_fields_to_use_[DESTINATION_PORT]);
+    }
+    bool is_ip_protocol_set() const {
+        return (hash_fields_to_use_[IP_PROTOCOL]);
+    }
+
+    void reset() {
+        for (uint8_t field_type = ((uint8_t) EcmpLoadBalance::SOURCE_MAC);
+             field_type < ((uint8_t) EcmpLoadBalance::NUM_HASH_FIELDS);
+             field_type++) {
+            hash_fields_to_use_[field_type] = false;
+        }
+    }
+
+    bool UpdateFields
+        (const autogen::EcmpHashingIncludeFields &ecmp_hashing_fields) {
+        bool ret = false;    
+
+        if (hash_fields_to_use_[SOURCE_MAC] != ecmp_hashing_fields.source_mac) {
+            hash_fields_to_use_[SOURCE_MAC] = ecmp_hashing_fields.source_mac;
+            ret = true;
+        }
+        if (hash_fields_to_use_[DESTINATION_MAC] !=
+            ecmp_hashing_fields.destination_mac) {
+            hash_fields_to_use_[DESTINATION_MAC] =
+                ecmp_hashing_fields.destination_mac;
+            ret = true;
+        }
+        if (hash_fields_to_use_[SOURCE_IP] != ecmp_hashing_fields.source_ip) {
+            hash_fields_to_use_[SOURCE_IP] = ecmp_hashing_fields.source_ip;
+            ret = true;
+        }
+        if (hash_fields_to_use_[DESTINATION_IP] !=
+            ecmp_hashing_fields.destination_ip) {
+            hash_fields_to_use_[DESTINATION_IP] =
+                ecmp_hashing_fields.destination_ip;
+            ret = true;
+        }
+        if (hash_fields_to_use_[SOURCE_PORT] !=
+            ecmp_hashing_fields.source_port) {
+            hash_fields_to_use_[SOURCE_PORT] = ecmp_hashing_fields.source_port;
+            ret = true;
+        }
+        if (hash_fields_to_use_[DESTINATION_PORT] !=
+            ecmp_hashing_fields.destination_port) {
+            hash_fields_to_use_[DESTINATION_PORT] =
+                ecmp_hashing_fields.destination_port;
+            ret = true;
+        }
+        if (hash_fields_to_use_[IP_PROTOCOL] !=
+            ecmp_hashing_fields.ip_protocol) {
+            hash_fields_to_use_[IP_PROTOCOL] = ecmp_hashing_fields.ip_protocol;
+            ret = true;
+        }
+        return ret;
+    }
+
+private:    
+    bool hash_fields_to_use_[NUM_HASH_FIELDS];
+};
+
+class VmiEcmpLoadBalance : public EcmpLoadBalance {
+public:
+    VmiEcmpLoadBalance() : EcmpLoadBalance(), use_global_vrouter_(true) { }
+    virtual ~VmiEcmpLoadBalance() { }
+
+    bool use_global_vrouter() const {return use_global_vrouter_;}
+    void set_use_global_vrouter(bool use_global_vrouter) {
+        use_global_vrouter_ = use_global_vrouter;
+    }
+
+private:
+    bool use_global_vrouter_;
+};
+
+#endif
diff --git a/src/vnsw/agent/oper/evpn_route.cc b/src/vnsw/agent/oper/evpn_route.cc
index 8f5b849d473..eff6b980c5a 100644
--- a/src/vnsw/agent/oper/evpn_route.cc
+++ b/src/vnsw/agent/oper/evpn_route.cc
@@ -7,6 +7,7 @@
 #include <cmn/agent_cmn.h>
 #include <route/route.h>
 
+#include <oper/ecmp_load_balance.h>
 #include <oper/route_common.h>
 #include <oper/vrf.h>
 #include <oper/tunnel_nh.h>
@@ -214,7 +215,8 @@ void EvpnAgentRouteTable::AddLocalVmRoute(const Peer *peer,
                                           InterfaceNHFlags::BRIDGE,
                                           sg_id_list, CommunityList(),
                                           path_pref,
-                                          IpAddress());
+                                          IpAddress(),
+                                          EcmpLoadBalance());
     data->set_tunnel_bmap(TunnelType::AllType());
 
     DBRequest req(DBRequest::DB_ENTRY_ADD_CHANGE);
diff --git a/src/vnsw/agent/oper/global_vrouter.cc b/src/vnsw/agent/oper/global_vrouter.cc
index f8b1832e986..ddf719a3928 100644
--- a/src/vnsw/agent/oper/global_vrouter.cc
+++ b/src/vnsw/agent/oper/global_vrouter.cc
@@ -23,6 +23,7 @@
 #include <oper/vxlan.h>
 #include <oper/mpls.h>
 #include <oper/route_common.h>
+#include <oper/ecmp_load_balance.h>
 
 #include <oper/agent_route_walker.h>
 #include <oper/agent_route_resync.h>
@@ -461,7 +462,8 @@ GlobalVrouter::GlobalVrouter(OperDB *oper)
       fabric_dns_resolver_(new FabricDnsResolver(this,
                            *(oper->agent()->event_manager()->io_service()))),
       agent_route_resync_walker_(new AgentRouteResync(oper->agent())),
-      forwarding_mode_(Agent::L2_L3), flow_export_rate_(kDefaultFlowExportRate){
+      forwarding_mode_(Agent::L2_L3), flow_export_rate_(kDefaultFlowExportRate),
+      ecmp_load_balance_() {
 
     DBTableBase *cfg_db = IFMapTable::FindTable(oper->agent()->db(),
               "global-vrouter-config");
@@ -493,8 +495,9 @@ void GlobalVrouter::GlobalVrouterConfig(DBTablePartBase *partition,
     IFMapNode *node = static_cast <IFMapNode *> (dbe);
     Agent::VxLanNetworkIdentifierMode cfg_vxlan_network_identifier_mode = 
                                             Agent::AUTOMATIC;
-    bool resync_vm_interface = false;
+    bool resync_vn = false; //resync_vn walks internally calls VMI walk.
     bool resync_route = false;
+
     if (node->IsDeleted() == false) {
         autogen::GlobalVrouterConfig *cfg = 
             static_cast<autogen::GlobalVrouterConfig *>(node->GetObject());
@@ -511,7 +514,7 @@ void GlobalVrouter::GlobalVrouterConfig(DBTablePartBase *partition,
         if (new_forwarding_mode != forwarding_mode_) {
             forwarding_mode_ = new_forwarding_mode;
             resync_route = true;
-            resync_vm_interface = true;
+            resync_vn = true;
         }
         if (cfg->IsPropertySet
                 (autogen::GlobalVrouterConfig::FLOW_EXPORT_RATE)) {
@@ -520,6 +523,8 @@ void GlobalVrouter::GlobalVrouterConfig(DBTablePartBase *partition,
             flow_export_rate_ = kDefaultFlowExportRate;
         }
         UpdateFlowAging(cfg);
+        resync_vn = ecmp_load_balance_.UpdateFields(cfg->
+                                              ecmp_hashing_include_fields());
     } else {
         DeleteLinkLocalServiceConfig();
         TunnelType::DeletePriorityList();
@@ -532,7 +537,7 @@ void GlobalVrouter::GlobalVrouterConfig(DBTablePartBase *partition,
         oper_->agent()->vxlan_network_identifier_mode()) {
         oper_->agent()->
             set_vxlan_network_identifier_mode(cfg_vxlan_network_identifier_mode);
-        resync_vm_interface = true;
+        resync_vn = true;
     }
 
     //Rebakes
@@ -543,12 +548,11 @@ void GlobalVrouter::GlobalVrouterConfig(DBTablePartBase *partition,
         //Update all routes irrespectively as this will handle change of
         //priority between MPLS-UDP to MPLS-GRE and vice versa.
         ResyncRoutes();
-        resync_vm_interface = true;
+        resync_vn = true;
     }
 
-    if (resync_vm_interface) {
+    if (resync_vn)
         oper_->agent()->vn_table()->GlobalVrouterConfigChanged();
-    }
 }
 
 // Get link local service configuration info, for a given service name
@@ -816,6 +820,10 @@ void GlobalVrouter::ResyncRoutes() {
     agent_route_resync_walker_.get()->Update();
 }
 
+const EcmpLoadBalance &GlobalVrouter::ecmp_load_balance() const {
+    return ecmp_load_balance_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void LinkLocalServiceInfo::HandleRequest() const {
diff --git a/src/vnsw/agent/oper/global_vrouter.h b/src/vnsw/agent/oper/global_vrouter.h
index 3d83f4e0e94..8b17f36fa32 100644
--- a/src/vnsw/agent/oper/global_vrouter.h
+++ b/src/vnsw/agent/oper/global_vrouter.h
@@ -14,6 +14,7 @@ class IFMapNode;
 class AgentRouteResync;
 class AgentRouteEncap;
 class AgentUtXmlFlowThreshold;
+class EcmpLoadBalance;
 
 namespace autogen {
     struct LinklocalServiceEntryType;
@@ -114,6 +115,7 @@ class GlobalVrouter {
 
     uint64_t PendingFabricDnsRequests() const;
     void ResyncRoutes();
+    const EcmpLoadBalance &ecmp_load_balance() const;
 
     friend class AgentUtXmlFlowThreshold;
 private:
@@ -142,6 +144,7 @@ class GlobalVrouter {
     Agent::ForwardingMode forwarding_mode_;
     uint32_t flow_export_rate_;
     FlowAgingTimeoutMap flow_aging_timeout_map_;
+    EcmpLoadBalance ecmp_load_balance_;
 };
 
 #endif // vnsw_agent_global_router_h_
diff --git a/src/vnsw/agent/oper/inet_unicast_route.cc b/src/vnsw/agent/oper/inet_unicast_route.cc
index 23728a3e74e..c56eb78b1f9 100644
--- a/src/vnsw/agent/oper/inet_unicast_route.cc
+++ b/src/vnsw/agent/oper/inet_unicast_route.cc
@@ -9,6 +9,7 @@
 #include <cmn/agent_cmn.h>
 #include "net/address_util.h"
 #include <route/route.h>
+#include <oper/ecmp_load_balance.h>
 #include <oper/route_common.h>
 #include <oper/vrf.h>
 #include <oper/tunnel_nh.h>
@@ -336,6 +337,7 @@ bool InetUnicastRouteEntry::ModifyEcmpPath(const IpAddress &dest_addr,
                                             SecurityGroupList sg_list,
                                             const PathPreference &path_preference,
                                             TunnelType::TypeBmap tunnel_bmap,
+                                            const EcmpLoadBalance &ecmp_load_balance,
                                             DBRequest &nh_req,
                                             Agent* agent, AgentPath *path) {
     bool ret = false;
@@ -373,6 +375,11 @@ bool InetUnicastRouteEntry::ModifyEcmpPath(const IpAddress &dest_addr,
     path->set_dest_vn_list(vn_list);
     ret = true;
     path->set_unresolved(false);
+    if (path->ecmp_load_balance() != ecmp_load_balance) {
+        path->set_ecmp_load_balance(ecmp_load_balance);
+        ret = true;
+    }
+
     if (path->ChangeNH(agent, nh) == true)
         ret = true;
 
@@ -424,6 +431,7 @@ AgentPath *InetUnicastRouteEntry::AllocateEcmpPath(Agent *agent,
                                            path2->sg_list(),
                                            path2->path_preference(),
                                            path2->tunnel_bmap(),
+                                           path2->ecmp_load_balance(),
                                            nh_req, agent, path);
 
     //Make MPLS label point to Composite NH
@@ -619,7 +627,8 @@ bool InetUnicastRouteEntry::EcmpAddPath(AgentPath *path) {
     return true;
 }
 
-void InetUnicastRouteEntry::AppendEcmpPath(Agent *agent, AgentPath *path) {
+void InetUnicastRouteEntry::AppendEcmpPath(Agent *agent,
+                                           AgentPath *path) {
     AgentPath *ecmp_path = FindPath(agent->ecmp_peer());
     assert(ecmp_path);
 
@@ -644,7 +653,9 @@ void InetUnicastRouteEntry::AppendEcmpPath(Agent *agent, AgentPath *path) {
     InetUnicastRouteEntry::ModifyEcmpPath(addr_, plen_, path->dest_vn_list(),
                                ecmp_path->label(), true, vrf()->GetName(),
                                path->sg_list(), path->path_preference(),
-                               path->tunnel_bmap(), nh_req, agent, ecmp_path);
+                               path->tunnel_bmap(),
+                               path->ecmp_load_balance(),
+                               nh_req, agent, ecmp_path);
 
     //Make MPLS label point to composite NH
     MplsLabel::CreateEcmpLabel(agent, ecmp_path->label(), Composite::LOCAL_ECMP,
@@ -685,7 +696,9 @@ void InetUnicastRouteEntry::DeleteComponentNH(Agent *agent, AgentPath *path) {
                                ecmp_path->dest_vn_list(),
                                ecmp_path->label(), true, vrf()->GetName(),
                                ecmp_path->sg_list(), ecmp_path->path_preference(),
-                               ecmp_path->tunnel_bmap(), nh_req, agent, ecmp_path);
+                               ecmp_path->tunnel_bmap(),
+                               ecmp_path->ecmp_load_balance(),
+                               nh_req, agent, ecmp_path);
 
     //Make MPLS label point to composite NH
     MplsLabel::CreateEcmpLabel(agent, ecmp_path->label(), Composite::LOCAL_ECMP,
@@ -1114,12 +1127,15 @@ InetUnicastAgentRouteTable::AddLocalVmRouteReq(const Peer *peer,
                                                bool force_policy,
                                                const PathPreference
                                                &path_preference,
-                                               const IpAddress &subnet_service_ip) {
+                                               const IpAddress &subnet_service_ip,
+                                               const EcmpLoadBalance &ecmp_load_balance)
+{
     VmInterfaceKey intf_key(AgentKey::ADD_DEL_CHANGE, intf_uuid, "");
     LocalVmRoute *data = new LocalVmRoute(intf_key, label,
                                     VxLanTable::kInvalidvxlan_id, force_policy,
                                     vn_list, InterfaceNHFlags::INET4, sg_list,
-                                    communities, path_preference, subnet_service_ip);
+                                    communities, path_preference,
+                                    subnet_service_ip, ecmp_load_balance);
 
     AddLocalVmRouteReq(peer, vm_vrf, addr, plen, data);
 }
@@ -1151,7 +1167,8 @@ InetUnicastAgentRouteTable::AddLocalVmRoute(const Peer *peer,
                                             bool force_policy,
                                             const PathPreference
                                             &path_preference,
-                                            const IpAddress &subnet_service_ip)
+                                            const IpAddress &subnet_service_ip,
+                                            const EcmpLoadBalance &ecmp_load_balance)
 {
     DBRequest req(DBRequest::DB_ENTRY_ADD_CHANGE);
     req.key.reset(new InetUnicastRouteKey(peer, vm_vrf, addr, plen));
@@ -1160,7 +1177,8 @@ InetUnicastAgentRouteTable::AddLocalVmRoute(const Peer *peer,
     req.data.reset(new LocalVmRoute(intf_key, label, VxLanTable::kInvalidvxlan_id,
                                     force_policy, vn_list,
                                     InterfaceNHFlags::INET4, sg_list, communities,
-                                    path_preference, subnet_service_ip));
+                                    path_preference, subnet_service_ip,
+                                    ecmp_load_balance));
     InetUnicastTableProcess(Agent::GetInstance(), vm_vrf, req);
 }
 
diff --git a/src/vnsw/agent/oper/inet_unicast_route.h b/src/vnsw/agent/oper/inet_unicast_route.h
index c985deadd54..bbfc3b9f18b 100644
--- a/src/vnsw/agent/oper/inet_unicast_route.h
+++ b/src/vnsw/agent/oper/inet_unicast_route.h
@@ -9,6 +9,7 @@ class VlanNhRoute;
 class LocalVmRoute;
 class InetInterfaceRoute;
 class ClonedLocalPath;
+class EcmpLoadBalance;
 
 //////////////////////////////////////////////////////////////////
 //  UNICAST INET
@@ -82,6 +83,7 @@ class InetUnicastRouteEntry : public AgentRoute {
                                SecurityGroupList sg_list,
                                const PathPreference &path_preference,
                                TunnelType::TypeBmap tunnel_bmap,
+                               const EcmpLoadBalance &ecmp_ecmp_load_balance,
                                DBRequest &nh_req,
                                Agent* agent,
                                AgentPath *path);
@@ -207,7 +209,8 @@ class InetUnicastAgentRouteTable : public AgentRouteTable {
                             const CommunityList &communities,
                             bool force_policy,
                             const PathPreference &path_preference,
-                            const IpAddress &subnet_service_ip);
+                            const IpAddress &subnet_service_ip,
+                            const EcmpLoadBalance &ecmp_load_balance);
     static void AddLocalVmRoute(const Peer *peer, const string &vm_vrf,
                                 const IpAddress &addr, uint8_t plen,
                                 const uuid &intf_uuid,
@@ -217,7 +220,8 @@ class InetUnicastAgentRouteTable : public AgentRouteTable {
                                 const CommunityList &communities,
                                 bool force_policy,
                                 const PathPreference &path_preference,
-                                const IpAddress &subnet_service_ip);
+                                const IpAddress &subnet_service_ip,
+                                const EcmpLoadBalance &ecmp_load_balance);
     static void AddRemoteVmRouteReq(const Peer *peer, const string &vm_vrf,
                                     const IpAddress &vm_addr,uint8_t plen,
                                     AgentRouteData *data);
diff --git a/src/vnsw/agent/oper/interface.cc b/src/vnsw/agent/oper/interface.cc
index 816d0fba033..c60ce78c108 100644
--- a/src/vnsw/agent/oper/interface.cc
+++ b/src/vnsw/agent/oper/interface.cc
@@ -295,8 +295,8 @@ bool InterfaceTable::L2VmInterfaceWalk(DBTablePartBase *partition,
         return true;
 
     VmInterfaceGlobalVrouterData data(vn->bridging(),
-                                      vn->layer3_forwarding(),
-                                      vn->GetVxLanId());
+                                 vn->layer3_forwarding(),
+                                 vn->GetVxLanId());
     return vm_intf->Resync(this, &data);
 }
 
diff --git a/src/vnsw/agent/oper/metadata_ip.cc b/src/vnsw/agent/oper/metadata_ip.cc
index 1200a9e2076..b4190a221c5 100644
--- a/src/vnsw/agent/oper/metadata_ip.cc
+++ b/src/vnsw/agent/oper/metadata_ip.cc
@@ -3,6 +3,7 @@
  */
 
 #include <oper/route_common.h>
+#include <oper/ecmp_load_balance.h>
 #include <oper/interface_common.h>
 #include <oper/vm_interface.h>
 #include <oper/inet_unicast_route.h>
@@ -119,6 +120,7 @@ void MetaDataIpAllocator::ReleaseIndex(MetaDataIp *ip) {
 
 void MetaDataIpAllocator::AddFabricRoute(MetaDataIp *ip) {
     PathPreference path_preference;
+    EcmpLoadBalance ecmp_load_balance;
     ip->intf_->SetPathPreference(&path_preference, false, Ip4Address(0));
 
     VnListType vn_list;
@@ -127,7 +129,8 @@ void MetaDataIpAllocator::AddFabricRoute(MetaDataIp *ip) {
         (agent_->link_local_peer(), agent_->fabric_vrf_name(),
          ip->GetLinkLocalIp(), 32, ip->intf_->GetUuid(),
          vn_list, ip->intf_->label(), SecurityGroupList(),
-         CommunityList(), true, path_preference, Ip4Address(0));
+         CommunityList(), true, path_preference, Ip4Address(0),
+         ecmp_load_balance);
 }
 
 void MetaDataIpAllocator::DelFabricRoute(MetaDataIp *ip) {
diff --git a/src/vnsw/agent/oper/vm_interface.cc b/src/vnsw/agent/oper/vm_interface.cc
index 4ecd4a7e9bc..ad4773f86d4 100644
--- a/src/vnsw/agent/oper/vm_interface.cc
+++ b/src/vnsw/agent/oper/vm_interface.cc
@@ -35,6 +35,8 @@
 #include <oper/oper_dhcp_options.h>
 #include <oper/inet_unicast_route.h>
 #include <oper/physical_device_vn.h>
+#include <oper/ecmp_load_balance.h>
+#include <oper/global_vrouter.h>
 #include <oper/ifmap_dependency_manager.h>
 
 #include <vnc_cfg_types.h>
@@ -70,7 +72,8 @@ VmInterface::VmInterface(const boost::uuids::uuid &uuid) :
     vmi_type_(VmInterface::VMI_TYPE_INVALID),
     configurer_(0), subnet_(0), subnet_plen_(0), ethernet_tag_(0),
     logical_interface_(nil_uuid()), nova_ip_addr_(0), nova_ip6_addr_(),
-    dhcp_addr_(0), metadata_ip_map_(), hc_instance_set_() {
+    dhcp_addr_(0), metadata_ip_map_(), hc_instance_set_(),
+    ecmp_load_balance_() {
     metadata_ip_active_ = false;
     ipv4_active_ = false;
     ipv6_active_ = false;
@@ -684,6 +687,36 @@ static PhysicalRouter *BuildParentInfo(Agent *agent,
     return NULL;
 }
 
+static void BuildEcmpHashingIncludeFields(VirtualMachineInterface *cfg,
+                                          IFMapNode *vn_node,
+                                          VmInterfaceConfigData *data) {
+    data->ecmp_load_balance_.set_use_global_vrouter(false);
+    if (cfg->IsPropertySet
+        (VirtualMachineInterface::ECMP_HASHING_INCLUDE_FIELDS)) {
+        data->ecmp_load_balance_.UpdateFields(cfg->
+                                              ecmp_hashing_include_fields());
+    } else {
+        //Extract from VN
+        if (!vn_node) {
+            data->ecmp_load_balance_.reset();
+            data->ecmp_load_balance_.set_use_global_vrouter(true);
+            return;
+        }
+        VirtualNetwork *vn_cfg =
+            static_cast <VirtualNetwork *> (vn_node->GetObject());
+        if (vn_cfg->IsPropertySet
+            (VirtualNetwork::ECMP_HASHING_INCLUDE_FIELDS) ==
+            false) {
+            data->ecmp_load_balance_.set_use_global_vrouter(true);
+            data->ecmp_load_balance_.reset();
+            return;
+        }
+        data->ecmp_load_balance_.UpdateFields(vn_cfg->
+                                              ecmp_hashing_include_fields());
+    }
+
+}
+
 static void BuildAttributes(Agent *agent, IFMapNode *node,
                             VirtualMachineInterface *cfg,
                             VmInterfaceConfigData *data) {
@@ -957,6 +990,7 @@ bool InterfaceTable::VmiProcessConfig(IFMapNode *node, DBRequest &req,
     // Build parent for the virtual-machine-interface
     prouter = BuildParentInfo(agent_, data, cfg, node, li_node,
                               parent_vmi_node);
+    BuildEcmpHashingIncludeFields(cfg, vn_node, data);
 
     // Compute device-type and vmi-type for the interface
     ComputeTypeInfo(agent_, data, cfg_entry, prouter, node, li_node);
@@ -1565,7 +1599,7 @@ VmInterfaceConfigData::VmInterfaceConfigData(Agent *agent, IFMapNode *node) :
     physical_interface_(""), parent_vmi_(), subnet_(0), subnet_plen_(0),
     rx_vlan_id_(VmInterface::kInvalidVlanId),
     tx_vlan_id_(VmInterface::kInvalidVlanId),
-    logical_interface_(nil_uuid()) {
+    logical_interface_(nil_uuid()), ecmp_load_balance_() {
 }
 
 VmInterface *VmInterfaceConfigData::OnAdd(const InterfaceTable *table,
@@ -1596,11 +1630,13 @@ bool VmInterfaceConfigData::OnResync(const InterfaceTable *table,
     bool sg_changed = false;
     bool ecmp_changed = false;
     bool local_pref_changed = false;
+    bool ecmp_load_balance_changed = false;
     bool ret = false;
 
     ret = vmi->CopyConfig(table, this, &sg_changed, &ecmp_changed,
-                          &local_pref_changed);
-    if (sg_changed || ecmp_changed || local_pref_changed)
+                          &local_pref_changed, &ecmp_load_balance_changed);
+    if (sg_changed || ecmp_changed || local_pref_changed ||
+        ecmp_load_balance_changed)
         *force_update = true;
 
     return ret;
@@ -1611,7 +1647,9 @@ bool VmInterfaceConfigData::OnResync(const InterfaceTable *table,
 bool VmInterface::CopyConfig(const InterfaceTable *table,
                              const VmInterfaceConfigData *data,
                              bool *sg_changed,
-                             bool *ecmp_changed, bool *local_pref_changed) {
+                             bool *ecmp_changed,
+                             bool *local_pref_changed,
+                             bool *ecmp_load_balance_changed) {
     bool ret = false;
     if (table) {
         VmEntry *vm = table->FindVmRef(data->vm_uuid_);
@@ -1897,6 +1935,11 @@ bool VmInterface::CopyConfig(const InterfaceTable *table,
         }
     }
 
+    if (ecmp_load_balance_ != data->ecmp_load_balance_) {
+        ecmp_load_balance_.Copy(data->ecmp_load_balance_);
+        *ecmp_load_balance_changed = true;
+        ret = true;
+    }
     return ret;
 }
 
@@ -2107,6 +2150,11 @@ bool VmInterfaceGlobalVrouterData::OnResync(const InterfaceTable *table,
     if (vxlan_id_ != vmi->vxlan_id_)
         ret = true;
 
+    if (vmi->ecmp_load_balance().use_global_vrouter()) {
+        *force_update = true;
+        ret = true;
+    }
+
     return ret;
 }
 
@@ -2587,9 +2635,9 @@ IpAddress VmInterface::GetServiceIp(const IpAddress &vm_ip) const {
 
 // Add/Update route. Delete old route if VRF or address changed
 void VmInterface::UpdateIpv4InterfaceRoute(bool old_ipv4_active, bool force_update,
-                                         bool policy_change,
-                                         VrfEntry * old_vrf,
-                                         const Ip4Address &old_addr) {
+                            bool policy_change,
+                            VrfEntry * old_vrf,
+                            const Ip4Address &old_addr) {
     Ip4Address ip = GetServiceIp(primary_ip_addr_).to_v4();
 
     // If interface was already active earlier and there is no force_update or
@@ -2609,7 +2657,7 @@ void VmInterface::UpdateIpv4InterfaceRoute(bool old_ipv4_active, bool force_upda
             AddRoute(vrf_->GetName(), primary_ip_addr_, 32, vn_->GetName(),
                      policy_enabled_, ecmp_, vm_ip_service_addr_, Ip4Address(0),
                      CommunityList());
-        } else if (policy_change == true) {
+        } else if (policy_change) {
             // If old-l3-active and there is change in policy, invoke RESYNC of
             // route to account for change in NH policy
             InetUnicastAgentRouteTable::ReEvaluatePaths(agent(),
@@ -2659,7 +2707,7 @@ void VmInterface::DeleteResolveRoute(VrfEntry *old_vrf,
 }
 
 void VmInterface::DeleteIpv4InterfaceRoute(VrfEntry *old_vrf,
-                                           const Ip4Address &old_addr) {
+                            const Ip4Address &old_addr) {
     if ((old_vrf == NULL) || (old_addr.to_ulong() == 0))
         return;
 
@@ -3149,6 +3197,13 @@ void VmInterface::SetPathPreference(PathPreference *pref, bool ecmp,
     pref->set_vrf(vrf()->GetName());
 }
 
+void VmInterface::CopyEcmpLoadBalance(EcmpLoadBalance &ecmp_load_balance) {
+    if (ecmp_load_balance_.use_global_vrouter() == false)
+        return ecmp_load_balance.Copy(ecmp_load_balance_);
+    return ecmp_load_balance.Copy(agent()->oper_db()->global_vrouter()->
+                                  ecmp_load_balance());
+}
+
 //Add a route for VM port
 //If ECMP route, add new composite NH and mpls label for same
 void VmInterface::AddRoute(const std::string &vrf_name, const IpAddress &addr,
@@ -3164,11 +3219,14 @@ void VmInterface::AddRoute(const std::string &vrf_name, const IpAddress &addr,
 
     VnListType vn_list;
     vn_list.insert(dest_vn);
+    EcmpLoadBalance ecmp_load_balance;
+    CopyEcmpLoadBalance(ecmp_load_balance);
     InetUnicastAgentRouteTable::AddLocalVmRoute(peer_.get(), vrf_name, addr,
                                                  plen, GetUuid(),
                                                  vn_list, label_,
                                                  sg_id_list, communities, false,
-                                                 path_preference, service_ip);
+                                                 path_preference, service_ip,
+                                                 ecmp_load_balance);
     return;
 }
 
diff --git a/src/vnsw/agent/oper/vm_interface.h b/src/vnsw/agent/oper/vm_interface.h
index 81459a03ddb..4d66522a444 100644
--- a/src/vnsw/agent/oper/vm_interface.h
+++ b/src/vnsw/agent/oper/vm_interface.h
@@ -7,6 +7,7 @@
 
 #include <oper/oper_dhcp_options.h>
 #include <oper/audit_list.h>
+#include <oper/ecmp_load_balance.h>
 
 /////////////////////////////////////////////////////////////////////////////
 // Implementation of VM Port interfaces
@@ -620,6 +621,7 @@ class VmInterface : public Interface {
     uint32_t ethernet_tag() const {return ethernet_tag_;}
     void UpdateVxLan();
     bool IsActive() const;
+    const VmiEcmpLoadBalance &ecmp_load_balance() const {return ecmp_load_balance_;}
     Agent *agent() const {
         return (static_cast<InterfaceTable *>(get_table()))->agent();
     }
@@ -667,7 +669,8 @@ class VmInterface : public Interface {
                            bool old_dhcp_enable);
     bool CopyConfig(const InterfaceTable *table,
                     const VmInterfaceConfigData *data, bool *sg_changed,
-                    bool *ecmp_changed, bool *local_pref_changed);
+                    bool *ecmp_changed, bool *local_pref_changed,
+                    bool *ecmp_load_balance_changed);
     void ApplyConfig(bool old_ipv4_active,bool old_l2_active,  bool old_policy,
                      VrfEntry *old_vrf, const Ip4Address &old_addr,
                      int old_ethernet_tag, bool old_need_linklocal_ip,
@@ -772,6 +775,7 @@ class VmInterface : public Interface {
     void DeleteL2ReceiveRoute(const VrfEntry *old_vrf, bool old_l2_active);
 
     bool UpdateIsHealthCheckActive();
+    void CopyEcmpLoadBalance(EcmpLoadBalance &ecmp_load_balance);
 
     VmEntryRef vm_;
     VnEntryRef vn_;
@@ -839,6 +843,7 @@ class VmInterface : public Interface {
     Ip4Address dhcp_addr_;
     MetaDataIpMap metadata_ip_map_;
     HealthCheckInstanceSet hc_instance_set_;
+    VmiEcmpLoadBalance ecmp_load_balance_;
     DISALLOW_COPY_AND_ASSIGN(VmInterface);
 };
 
@@ -995,6 +1000,7 @@ struct VmInterfaceConfigData : public VmInterfaceData {
     uint16_t rx_vlan_id_;
     uint16_t tx_vlan_id_;
     boost::uuids::uuid logical_interface_;
+    VmiEcmpLoadBalance ecmp_load_balance_;
 };
 
 // Definition for structures when request queued from Nova
diff --git a/src/vnsw/agent/pkt/flow_mgmt_dbclient.cc b/src/vnsw/agent/pkt/flow_mgmt_dbclient.cc
index 9b9842c7da8..528f7061e00 100644
--- a/src/vnsw/agent/pkt/flow_mgmt_dbclient.cc
+++ b/src/vnsw/agent/pkt/flow_mgmt_dbclient.cc
@@ -1,4 +1,5 @@
 #include "pkt/flow_mgmt_dbclient.h"
+#include "oper/ecmp_load_balance.h"
 
 void FlowMgmtDbClient::Init() {
     acl_listener_id_ = agent_->acl_table()->Register
@@ -572,6 +573,11 @@ void FlowMgmtDbClient::RouteNotify(VrfFlowHandlerState *vrf_state,
         }
     }
 
+    if (state->ecmp_load_balance_ != path->ecmp_load_balance()) {
+        state->ecmp_load_balance_ = path->ecmp_load_balance();
+        changed = true;
+    }
+
     if (changed == true && new_route == false) {
         ChangeEvent(route, state);
     }
diff --git a/src/vnsw/agent/pkt/flow_mgmt_dbclient.h b/src/vnsw/agent/pkt/flow_mgmt_dbclient.h
index 784d11e3588..153e94ee3ea 100644
--- a/src/vnsw/agent/pkt/flow_mgmt_dbclient.h
+++ b/src/vnsw/agent/pkt/flow_mgmt_dbclient.h
@@ -6,6 +6,7 @@
 
 #include "pkt/flow_mgmt.h"
 
+class EcmpLoadBalance;
 ////////////////////////////////////////////////////////////////////////////
 // Request to the Flow Management module
 ////////////////////////////////////////////////////////////////////////////
@@ -72,7 +73,8 @@ class FlowMgmtDbClient {
     };
 
     struct RouteFlowHandlerState : public FlowMgmtState {
-        RouteFlowHandlerState() : sg_l_(), active_nh_(NULL), local_nh_(NULL) {}
+        RouteFlowHandlerState() : sg_l_(), active_nh_(NULL), local_nh_(NULL),
+            ecmp_load_balance_() {}
         virtual ~RouteFlowHandlerState() { }
         typedef std::map<InterfaceConstRef, IpAddress> FixedIpMap;
         typedef std::pair<InterfaceConstRef, IpAddress> FixedIpEntry;
@@ -81,6 +83,7 @@ class FlowMgmtDbClient {
         const NextHop* active_nh_;
         const NextHop* local_nh_;
         FixedIpMap fixed_ip_map_;
+        EcmpLoadBalance ecmp_load_balance_;
     };
 
     struct NhFlowHandlerState : public FlowMgmtState {
diff --git a/src/vnsw/agent/pkt/pkt_flow_info.cc b/src/vnsw/agent/pkt/pkt_flow_info.cc
index 488279bd7c6..e4dd070e93a 100644
--- a/src/vnsw/agent/pkt/pkt_flow_info.cc
+++ b/src/vnsw/agent/pkt/pkt_flow_info.cc
@@ -190,7 +190,8 @@ static bool IsVgwOrVmInterface(const Interface *intf) {
 // This is to avoid routing across fabric interface itself
 static bool NhDecode(const NextHop *nh, const PktInfo *pkt, PktFlowInfo *info,
                      PktControlInfo *in, PktControlInfo *out,
-                     bool force_vmport) {
+                     bool force_vmport,
+                     const EcmpLoadBalance &ecmp_load_balance) {
     bool ret = true;
 
     if (!nh->IsActive())
@@ -222,7 +223,8 @@ static bool NhDecode(const NextHop *nh, const PktInfo *pkt, PktFlowInfo *info,
             if (info->out_component_nh_idx ==
                 CompositeNH::kInvalidComponentNHIdx ||
                 (comp_nh->GetNH(info->out_component_nh_idx) == NULL)) {
-                info->out_component_nh_idx = comp_nh->hash(pkt->hash());
+                info->out_component_nh_idx = comp_nh->hash(pkt->
+                                             hash(ecmp_load_balance));
             }
             nh = comp_nh->GetNH(info->out_component_nh_idx);
             // TODO: Should we re-hash here?
@@ -397,7 +399,8 @@ static bool RouteToOutInfo(const AgentRoute *rt, const PktInfo *pkt,
         return false;
     }
 
-    return NhDecode(nh, pkt, info, in, out, false);
+    return NhDecode(nh, pkt, info, in, out, false,
+                    path->ecmp_load_balance());
 }
 
 static const VnEntry *InterfaceToVn(const Interface *intf) {
@@ -1311,7 +1314,8 @@ void PktFlowInfo::EgressProcess(const PktInfo *pkt, PktControlInfo *in,
     if (nh == NULL) {
         return;
     }
-    if (NhDecode(nh, pkt, this, in, out, true) == false) {
+    //Delay hash pick up till route is picked.
+    if (NhDecode(nh, pkt, this, in, out, true, EcmpLoadBalance()) == false) {
         return;
     }
 
@@ -1355,6 +1359,12 @@ void PktFlowInfo::EgressProcess(const PktInfo *pkt, PktControlInfo *in,
     }
 
     if (out->rt_) {
+        if (ecmp && out->rt_->GetActivePath()) {
+            const CompositeNH *comp_nh = static_cast<const CompositeNH *>(nh);
+            out_component_nh_idx = comp_nh->hash(pkt->
+                                   hash(out->rt_->GetActivePath()->
+                                        ecmp_load_balance()));
+        }
         if (out->rt_->GetActiveNextHop()->GetType() == NextHop::ARP ||
             out->rt_->GetActiveNextHop()->GetType() == NextHop::RESOLVE) {
             //If a packet came with mpls label pointing to
diff --git a/src/vnsw/agent/pkt/pkt_handler.cc b/src/vnsw/agent/pkt/pkt_handler.cc
index 66a06d3379b..117515f6b0f 100644
--- a/src/vnsw/agent/pkt/pkt_handler.cc
+++ b/src/vnsw/agent/pkt/pkt_handler.cc
@@ -11,6 +11,7 @@
 
 #include "cmn/agent_cmn.h"
 #include "net/address_util.h"
+#include "oper/ecmp_load_balance.h"
 #include "oper/interface_common.h"
 #include "oper/nexthop.h"
 #include "oper/route_common.h"
@@ -914,31 +915,46 @@ void PktInfo::UpdateHeaderPtr() {
     transp.tcp = (struct tcphdr *)(ip + 1);
 }
 
-std::size_t PktInfo::hash() const {
+std::size_t PktInfo::hash(const EcmpLoadBalance &ecmp_load_balance) const {
     std::size_t seed = 0;
+
     if (family == Address::INET) {
-        boost::hash_combine(seed, ip_saddr.to_v4().to_ulong());
-        boost::hash_combine(seed, ip_daddr.to_v4().to_ulong());
+        if (ecmp_load_balance.is_source_ip_set()) {
+            boost::hash_combine(seed, ip_saddr.to_v4().to_ulong());
+        }
+        if (ecmp_load_balance.is_destination_ip_set()) {
+            boost::hash_combine(seed, ip_daddr.to_v4().to_ulong());
+        }
     } else if (family == Address::INET6) {
         uint32_t *words;
 
-        words = (uint32_t *) (ip_saddr.to_v6().to_bytes().c_array());
-        boost::hash_combine(seed, words[0]);
-        boost::hash_combine(seed, words[1]);
-        boost::hash_combine(seed, words[2]);
-        boost::hash_combine(seed, words[3]);
-
-        words = (uint32_t *) (ip_daddr.to_v6().to_bytes().c_array());
-        boost::hash_combine(seed, words[0]);
-        boost::hash_combine(seed, words[1]);
-        boost::hash_combine(seed, words[2]);
-        boost::hash_combine(seed, words[3]);
+        if (ecmp_load_balance.is_source_ip_set()) {
+            words = (uint32_t *) (ip_saddr.to_v6().to_bytes().c_array());
+            boost::hash_combine(seed, words[0]);
+            boost::hash_combine(seed, words[1]);
+            boost::hash_combine(seed, words[2]);
+            boost::hash_combine(seed, words[3]);
+        }
+
+        if (ecmp_load_balance.is_destination_ip_set()) {
+            words = (uint32_t *) (ip_daddr.to_v6().to_bytes().c_array());
+            boost::hash_combine(seed, words[0]);
+            boost::hash_combine(seed, words[1]);
+            boost::hash_combine(seed, words[2]);
+            boost::hash_combine(seed, words[3]);
+        }
     } else {
         assert(0);
     }
-    boost::hash_combine(seed, ip_proto);
-    boost::hash_combine(seed, sport);
-    boost::hash_combine(seed, dport);
+    if (ecmp_load_balance.is_ip_protocol_set()) {
+        boost::hash_combine(seed, ip_proto);
+    }
+    if (ecmp_load_balance.is_source_port_set()) {
+        boost::hash_combine(seed, sport);
+    }
+    if (ecmp_load_balance.is_destination_port_set()) {
+        boost::hash_combine(seed, dport);
+    }
     return seed;
 }
 
diff --git a/src/vnsw/agent/pkt/pkt_handler.h b/src/vnsw/agent/pkt/pkt_handler.h
index 5ec71762c65..89a3d050122 100644
--- a/src/vnsw/agent/pkt/pkt_handler.h
+++ b/src/vnsw/agent/pkt/pkt_handler.h
@@ -36,7 +36,6 @@
 #define IPv4_ALEN           4
 #define ARP_TX_BUFF_LEN     128
 #define IPC_HDR_LEN        (sizeof(struct ether_header) + sizeof(struct agent_hdr))
-#define IP_PROTOCOL        ETHERTYPE_IP
 #define VLAN_PROTOCOL      0x8100
 #define DEFAULT_IP_TTL     64
 #define DEFAULT_IP_ID      0
@@ -48,6 +47,7 @@ struct PktInfo;
 struct agent_hdr;
 class PacketBuffer;
 class Proto;
+class EcmpLoadBalance;
 typedef boost::shared_ptr<PktInfo> PktInfoPtr;
 
 struct InterTaskMsg {
@@ -351,7 +351,7 @@ struct PktInfo {
 
     const AgentHdr &GetAgentHdr() const;
     void UpdateHeaderPtr();
-    std::size_t hash() const;
+    std::size_t hash(const EcmpLoadBalance &ecmp_has_fields_to_use) const;
 
     PacketBuffer *packet_buffer() const { return packet_buffer_.get(); }
     PacketBufferPtr packet_buffer_ptr() const { return packet_buffer_; }
diff --git a/src/vnsw/agent/pkt/test/test_flowtable.cc b/src/vnsw/agent/pkt/test/test_flowtable.cc
index 2e0aa4d8ac0..2a5f5194f9d 100644
--- a/src/vnsw/agent/pkt/test/test_flowtable.cc
+++ b/src/vnsw/agent/pkt/test/test_flowtable.cc
@@ -5,6 +5,7 @@
 #include "base/os.h"
 #include "test/test_cmn_util.h"
 #include "ksync/ksync_sock_user.h"
+#include "oper/ecmp_load_balance.h"
 
 #define MAX_VNET 4
 
@@ -130,7 +131,7 @@ class FlowTableTest : public ::testing::Test {
             AddLocalVmRouteReq(NULL, vrf, addr, 32, intf->GetUuid(),
                                vn_list, label,
                                SecurityGroupList(), CommunityList(), false, PathPreference(),
-                               Ip4Address(0));
+                               Ip4Address(0), EcmpLoadBalance());
         client->WaitForIdle();
         EXPECT_TRUE(RouteFind(vrf, addr, 32));
     }
diff --git a/src/vnsw/agent/pkt/test/test_pkt_flowv6.cc b/src/vnsw/agent/pkt/test/test_pkt_flowv6.cc
index 5fa2c92fbe0..a396e2a9ccc 100644
--- a/src/vnsw/agent/pkt/test/test_pkt_flowv6.cc
+++ b/src/vnsw/agent/pkt/test/test_pkt_flowv6.cc
@@ -7,6 +7,7 @@
 #include "test/test_cmn_util.h"
 #include "test_flow_util.h"
 #include "ksync/ksync_sock_user.h"
+#include "oper/ecmp_load_balance.h"
 #include "oper/tunnel_nh.h"
 #include "pkt/flow_table.h"
 
@@ -66,7 +67,8 @@ class FlowTestV6 : public ::testing::Test {
                                      vn_list, label,
                                      SecurityGroupList(), CommunityList(), false,
                                      PathPreference(),
-                                     Ip6Address());
+                                     Ip6Address(),
+                                     EcmpLoadBalance());
         client->WaitForIdle();
         EXPECT_TRUE(RouteFindV6(vrf, addr, 128));
     }
diff --git a/src/vnsw/agent/test/test_util.cc b/src/vnsw/agent/test/test_util.cc
index 0a0bf778c42..2e01197376b 100644
--- a/src/vnsw/agent/test/test_util.cc
+++ b/src/vnsw/agent/test/test_util.cc
@@ -7,6 +7,7 @@
 #include "base/os.h"
 #include "test/test_cmn_util.h"
 #include "test/test_init.h"
+#include "oper/ecmp_load_balance.h"
 #include "oper/mirror_table.h"
 #include "oper/physical_device_vn.h"
 #include "uve/test/vn_uve_table_test.h"
@@ -1451,7 +1452,8 @@ bool EcmpTunnelRouteAdd(const Peer *peer, const string &vrf_name, const Ip4Addre
     vn_list.insert(vn_name);
     ControllerEcmpRoute *data =
         new ControllerEcmpRoute(peer, vm_ip, plen, vn_list, -1, false, vrf_name,
-                                sg, path_preference, TunnelType::MplsType(), nh_req);
+                                sg, path_preference, TunnelType::MplsType(),
+                                EcmpLoadBalance(), nh_req);
     InetUnicastAgentRouteTable::AddRemoteVmRouteReq(peer, vrf_name, vm_ip, plen, data);
 }