{"id":1338,"date":"2022-01-20T09:38:10","date_gmt":"2022-01-20T09:38:10","guid":{"rendered":"https:\/\/www.mavensecurities.com\/?p=1338"},"modified":"2023-04-21T11:22:03","modified_gmt":"2023-04-21T10:22:03","slug":"many-clients-one-context-share-without-sharing","status":"publish","type":"post","link":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/","title":{"rendered":"Many Clients, One Context – Share Without Sharing"},"content":{"rendered":"

At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen – and they do – we can make split-second decisions to make a profit or to save ourselves from loss.<\/p>\n

We use C++ to achieve this, among other tools. It gives us what we need: the ability to write code which is high-level and which retains a significant amount of control over the machine.<\/p>\n

Writing code that is low-latency is not easy. It requires careful planning, making trade-offs and simply marking entire parts of the language as off-limits for latency-critical code. We have to remain vigilant because a carefully crafted market handler application can easily descend into unmaintainable and unintelligible spaghetti-code.<\/p>\n

So how do we keep our code both maintainable and fast? There are a few good guidelines to achieving this which we won’t dwell on here but the main, and perhaps most important one is this:<\/p>\n

Complexity minimization: if you don’t need it, don’t do it<\/p>\n

Is it really that important? Let’s use an example. At Maven we often end up with code which looks like this\u2026<\/p>\n

template<typename NextT>\r\nstruct FooHandler : private NextT\r\n{\r\n    struct FooContext { \/* ... *\/ };\r\n    SomeHashMap<OrderIdType, FooContext> mContexts;\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail)\r\n    {\r\n        \/\/ Lookup the context from the order ID.\r\n        FooContext& ourContext = mContexts[orderId];\r\n\r\n        \/\/ Perform some action which updates the context.\r\n        doFooTriggers(orderId, ourContext, detail);\r\n\r\n        \/\/ Call the next handler.\r\n        NextT::handle(tag, orderId, detail);\r\n    }\r\n};\r\n\r\ntemplate<typename NextT>\r\nstruct BarHandler : private NextT\r\n{\r\n    struct BarContext { \/* ... *\/ };\r\n    OtherHashMap<OrderIdType, BarContext> mContexts;\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail)\r\n    {\r\n        \/\/ Lookup the context from the order ID.\r\n        BarContext& ourContext = mContexts[orderId];\r\n\r\n        \/\/ Perform some action which updates the context.\r\n        doBarTriggers(orderId, ourContext, detail);\r\n\r\n        \/\/ Call the next handler.\r\n        NextT::handle(tag, orderId, detail);\r\n    }\r\n};\r\n\r\nstruct TerminalHandler\r\n{\r\n    void handle(auto tag, auto&&... args) { }\r\n};\r\n\r\nusing ComposedHandler = FooHandler< BarHandler< TerminalHandler > >;\r\n\r\nvoid marketLoop()\r\n{\r\n    ComposedHandler handler;\r\n    while (marketEvents.hasNext())\r\n    {\r\n        auto const& [id, detail] = marketEvents.next();\r\n        handler.handle(tags::OrderModified{}, id, detail);\r\n    }\r\n}\r\n<\/pre>\n
This is a simplification but the idea is that we keep our code maintainable by separating responsibilities. FooHandler and BarHandler each have their own distinct purpose, logic and data and each handler should be trivially replaceable. (In real code we might end up with a graph containing hundreds of handlers, so this separation really is important.)<\/p>\n
Can you spot the inefficiency? There are no virtual functions here; marketLoop calls FooHandler::handle calls BarHandler::handle calls TerminalHandler::handle which returns and we start again. If we used an object pool or custom allocators with our storage \u2013 as we should \u2013 then no heap allocations would be necessary either. But notice the innocent looking mContexts[orderId]<\/code>. It’s a hash table lookup and we do this not once but twice.<\/p>\n
Two or more hash lookups might not sound bad until you realise that each and every one of them may theoretically involve:<\/p>\n
    \n
  1. auto hash = std::hash<OrderIdType>{}();<\/code>
    \ncalculation of a hash code;<\/span><\/li>\n
  2. auto& bucket = buckets[hash & ~bucketMask];<\/code>
    \na mask or modulus to convert the hash code into a bucket index;<\/li>\n
  3. auto iter = std::find(std::begin(bucket), std::end(bucket), entry);<\/code>
    \nif the hash is bad quality, a linear scan through the hash map’s bucket entries with each step invoking operator==()<\/code> to check if it’s found its quarry (\u201cLinear Probing\u201d);<\/li>\n
  4. *iter<\/code> one or more iterator dereferences or memory lookups where each could involve a cache-miss.<\/li>\n<\/ol>\n
     <\/p>\n
    Yes, a hash table lookup is supposed to be an amortized constant – meaning something like Big-O notation’s O(1)<\/strong> – but that constant could be quite large. Furthermore, in our example of two lookups there’s no guarantee that each hash map’s content lies side-by-side in memory. These could in fact be megabytes apart.<\/p>\n
    So can we do better? Let’s introduce an OrderLookupHandler<\/code> into the chain, just before FooHandler<\/code>.<\/p>\n
    template<typename NextT>\r\nstruct OrderLookupHandler : private NextT\r\n{\r\n    using FooContext = NextT::FooContext;\r\n    using BarContext = NextT::NextT::BarContext;\r\n    using UnifiedContext = std::tuple<FooContext, BarContext>;\r\n\r\n    SomeHashMap<OrderIdType, UnifiedContext> mContexts;\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail)\r\n    {\r\n        \/\/ Lookup the context from the order ID.\r\n        UnifiedContext& context = mContexts[orderId];\r\n\r\n        \/\/ Call the next handler with the additional context.\r\n        NextT::handle(tag, orderId, detail, context);\r\n    }\r\n};\r\n\r\ntemplate<typename NextT_>\r\nstruct UnifiedFooHandler : private NextT_\r\n{\r\n    using NextT = NextT_;  \/\/ Exposes next step.\r\n    struct FooContext { \/* no longer private to UnifiedFooHandler *\/ };\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail,\r\n                auto& unifiedContext)  \/\/ <-- it doesn't know the type\r\n    {\r\n        \/\/ Lookup our part of the context.\r\n        FooContext& ourContext = std::get<FooContext>(unifiedContext);\r\n\r\n        \/\/ Perform some action which updates the context.\r\n        doFooTriggers(orderId, ourContext, detail);\r\n\r\n        \/\/ Call the next handler.\r\n        NextT::handle(tag, orderId, detail, unifiedContext);\r\n    }\r\n};\r\n\/\/...\r\n<\/pre>\n
     <\/p>\n
    Now each downstream handle<\/code> method takes the additional argument and – hey presto! – we turn two hash map lookups into one. But there are at least two downsides to this approach:<\/p>\n
      \n
    1. We have a tightly-coupled OrderLookupHandler<\/code> which now needs to know about the concrete types of FooContext<\/code> and BarContext<\/code>, and<\/li>\n
    2. Each downstream handler also needs these concrete types or must accept an anonymous or constrained auto&<\/code><\/li>\n<\/ol>\n
      This works but it isn’t as maintainable as it could be. We could create a concept and constrain our auto&<\/code> <\/span>argument or just be lazy and pass auto&&<\/code><\/span>. But, auto&&<\/code><\/span>\u00a0arguments allow any type to be passed whether it’s appropriate or not and inappropriate types generate <\/span>horrible<\/span><\/i> compilation errors!<\/span><\/p>\n
      Can we do better? Can we make the context type concrete and stop other handlers from looking into our private data? Yes! If each of the handlers and TerminalHandler include their own ContextType<\/code> then we can do this…<\/p>\n
      template<typename NextT>\r\nstruct BestOrderLookupHandler : private NextT\r\n{\r\n    using ContextType = NextT::ContextType;\r\n\r\n    SomeHashMap<OrderIdType, ContextType> mContexts;\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail)\r\n    {\r\n        \/\/ Lookup the context from the order ID.\r\n        ContextType& context = mContexts[orderId];\r\n\r\n        \/\/ Call the next handler with the additional context.\r\n        NextT::handle(tag, orderId, detail, context);\r\n    }\r\n};\r\n\r\ntemplate<typename NextT>\r\nstruct BestFooHandler : private NextT\r\n{\r\n    class FooContext : public NextT::ContextType\r\n    {\r\n        friend class BestFooHandler;\r\n\r\n        \/* private to BestFooHandler *\/\r\n    };\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail,\r\n                FooContext& ourContext)\r\n    {\r\n        \/\/ ...\r\n\r\n        \/\/ Calls to the next handler will implicitly upcast\r\n        \/\/ as static_cast<NextT::ContextType>(ourContext)\r\n        NextT::handle(tag, orderId, detail, ourContext);\r\n    }\r\n\r\n    using ContextType = FooContext;\r\n};\r\n\r\ntemplate<typename NextT>\r\nstruct BestBarHandler : private NextT\r\n{\r\n    class BarContext : public NextT::ContextType\r\n    {\r\n        friend class BestBarHandler;\r\n\r\n        \/* private to BestBarHandler *\/\r\n    };\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail,\r\n                BarContext& ourContext)\r\n    {\r\n        \/\/ ...\r\n\r\n        \/\/ Calls to the next handler will implicitly upcast\r\n        \/\/ as static_cast<NextT::ContextType>(ourContext)\r\n        NextT::handle(tag, orderId, detail, ourContext);\r\n    }\r\n\r\n    using ContextType = BarContext;\r\n};\r\n\r\nstruct BestTerminalHandler\r\n{\r\n    struct ContextType { \/* intentionally empty *\/ };\r\n\r\n    void handle(tags::OrderModified tag,\r\n                OrderIdType orderId,\r\n                OrderModifiedDetail const& detail,\r\n                ContextType& ourContext)\r\n    {\r\n        static_assert(sizeof(ourContext) == sizeof(ContextType),\r\n                      \"Our context is present and empty!\");\r\n    }\r\n};\r\n<\/pre>\n
       <\/p>\n
      Ta-daa! Now each handler has its own private context which it can mutate as it likes without worrying about other handlers messing with it or reading its secret contents. What is more, this way is fast. All the contexts now exploit spatial cache locality; they sit side-by-side making them very cache-friendly. So, the memory lookup is very likely paid for once and only once.<\/p>\n
      What is more, if we want to optimize the context-owning hash map then we only need to optimize this in one place. We could replace our HashMap in the OrderLookupHandler with a faster hash map or even an array and everyone downstream would immediately benefit.<\/p>\n
      As said earlier, programming with low-latency has its own challenges. But, these same challenges can lead to different approaches, interesting solutions and be very rewarding for the programmer.<\/p>\n
      Thanks for reading.<\/p>\n","protected":false},"excerpt":{"rendered":"
      At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen – and they do – we can make split-second decisions to make a profit or to save ourselves from loss. We use C++ to achieve this, among other tools. It gives us what we need: […]<\/p>\n","protected":false},"author":1,"featured_media":1339,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[9],"tags":[],"acf":[],"yoast_head":"\nMany Clients, One Context - Share Without Sharing - Maven Securities<\/title>\n<meta name=\"description\" content=\"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\" \/>\n<meta property=\"og:locale\" content=\"en_GB\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Many Clients, One Context - Share Without Sharing - Maven Securities\" \/>\n<meta property=\"og:description\" content=\"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\" \/>\n<meta property=\"og:site_name\" content=\"Maven Securities\" \/>\n<meta property=\"article:published_time\" content=\"2022-01-20T09:38:10+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-04-21T10:22:03+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg?strip=all&lossy=1&quality=80&ssl=1\" \/>\n\t<meta property=\"og:image:width\" content=\"1080\" \/>\n\t<meta property=\"og:image:height\" content=\"1080\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Maven\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Maven\" \/>\n\t<meta name=\"twitter:label2\" content=\"Estimated reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\"},\"author\":{\"name\":\"Maven\",\"@id\":\"https:\/\/www.mavensecurities.com\/#\/schema\/person\/6e060e241ee2d9cc49ba9746ae7bd550\"},\"headline\":\"Many Clients, One Context – Share Without Sharing\",\"datePublished\":\"2022-01-20T09:38:10+00:00\",\"dateModified\":\"2023-04-21T10:22:03+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\"},\"wordCount\":756,\"publisher\":{\"@id\":\"https:\/\/www.mavensecurities.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg\",\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-GB\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\",\"url\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\",\"name\":\"Many Clients, One Context - Share Without Sharing - Maven Securities\",\"isPartOf\":{\"@id\":\"https:\/\/www.mavensecurities.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg\",\"datePublished\":\"2022-01-20T09:38:10+00:00\",\"dateModified\":\"2023-04-21T10:22:03+00:00\",\"description\":\"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#breadcrumb\"},\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage\",\"url\":\"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg\",\"contentUrl\":\"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg\",\"width\":1080,\"height\":1080},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.mavensecurities.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Many Clients, One Context – Share Without Sharing\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.mavensecurities.com\/#website\",\"url\":\"https:\/\/www.mavensecurities.com\/\",\"name\":\"Maven Securities\",\"description\":\"Unleashing Potential\",\"publisher\":{\"@id\":\"https:\/\/www.mavensecurities.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.mavensecurities.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-GB\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.mavensecurities.com\/#organization\",\"name\":\"Maven Securities\",\"url\":\"https:\/\/www.mavensecurities.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/www.mavensecurities.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2020\/01\/Maven-LogoWeb.png?strip=all&lossy=1&quality=80&ssl=1\",\"contentUrl\":\"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2020\/01\/Maven-LogoWeb.png?strip=all&lossy=1&quality=80&ssl=1\",\"width\":852,\"height\":225,\"caption\":\"Maven Securities\"},\"image\":{\"@id\":\"https:\/\/www.mavensecurities.com\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.mavensecurities.com\/#\/schema\/person\/6e060e241ee2d9cc49ba9746ae7bd550\",\"name\":\"Maven\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/www.mavensecurities.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/e17d820df91c2a1e11f02cbb3b303500?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/e17d820df91c2a1e11f02cbb3b303500?s=96&d=mm&r=g\",\"caption\":\"Maven\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Many Clients, One Context - Share Without Sharing - Maven Securities","description":"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/","og_locale":"en_GB","og_type":"article","og_title":"Many Clients, One Context - Share Without Sharing - Maven Securities","og_description":"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.","og_url":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/","og_site_name":"Maven Securities","article_published_time":"2022-01-20T09:38:10+00:00","article_modified_time":"2023-04-21T10:22:03+00:00","og_image":[{"width":1080,"height":1080,"url":"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg?strip=all&lossy=1&quality=80&ssl=1","type":"image\/jpeg"}],"author":"Maven","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Maven","Estimated reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#article","isPartOf":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/"},"author":{"name":"Maven","@id":"https:\/\/www.mavensecurities.com\/#\/schema\/person\/6e060e241ee2d9cc49ba9746ae7bd550"},"headline":"Many Clients, One Context – Share Without Sharing","datePublished":"2022-01-20T09:38:10+00:00","dateModified":"2023-04-21T10:22:03+00:00","mainEntityOfPage":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/"},"wordCount":756,"publisher":{"@id":"https:\/\/www.mavensecurities.com\/#organization"},"image":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage"},"thumbnailUrl":"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg","articleSection":["Blog"],"inLanguage":"en-GB"},{"@type":"WebPage","@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/","url":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/","name":"Many Clients, One Context - Share Without Sharing - Maven Securities","isPartOf":{"@id":"https:\/\/www.mavensecurities.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage"},"image":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage"},"thumbnailUrl":"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg","datePublished":"2022-01-20T09:38:10+00:00","dateModified":"2023-04-21T10:22:03+00:00","description":"At Maven we need low-latency. We need to react to the changing market quickly so that when interesting things happen. Here's how we do it.","breadcrumb":{"@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#breadcrumb"},"inLanguage":"en-GB","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/"]}]},{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#primaryimage","url":"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg","contentUrl":"https:\/\/www.mavensecurities.com\/wp-content\/uploads\/2022\/01\/Maven.M9.Post2_.V3.jpg","width":1080,"height":1080},{"@type":"BreadcrumbList","@id":"https:\/\/www.mavensecurities.com\/many-clients-one-context-share-without-sharing\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.mavensecurities.com\/"},{"@type":"ListItem","position":2,"name":"Many Clients, One Context – Share Without Sharing"}]},{"@type":"WebSite","@id":"https:\/\/www.mavensecurities.com\/#website","url":"https:\/\/www.mavensecurities.com\/","name":"Maven Securities","description":"Unleashing Potential","publisher":{"@id":"https:\/\/www.mavensecurities.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.mavensecurities.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-GB"},{"@type":"Organization","@id":"https:\/\/www.mavensecurities.com\/#organization","name":"Maven Securities","url":"https:\/\/www.mavensecurities.com\/","logo":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/www.mavensecurities.com\/#\/schema\/logo\/image\/","url":"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2020\/01\/Maven-LogoWeb.png?strip=all&lossy=1&quality=80&ssl=1","contentUrl":"https:\/\/www-mavensecurities-com.exactdn.com\/wp-content\/uploads\/2020\/01\/Maven-LogoWeb.png?strip=all&lossy=1&quality=80&ssl=1","width":852,"height":225,"caption":"Maven Securities"},"image":{"@id":"https:\/\/www.mavensecurities.com\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/www.mavensecurities.com\/#\/schema\/person\/6e060e241ee2d9cc49ba9746ae7bd550","name":"Maven","image":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/www.mavensecurities.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/e17d820df91c2a1e11f02cbb3b303500?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/e17d820df91c2a1e11f02cbb3b303500?s=96&d=mm&r=g","caption":"Maven"}}]}},"_links":{"self":[{"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/posts\/1338"}],"collection":[{"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/comments?post=1338"}],"version-history":[{"count":2,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/posts\/1338\/revisions"}],"predecessor-version":[{"id":1341,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/posts\/1338\/revisions\/1341"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/media\/1339"}],"wp:attachment":[{"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/media?parent=1338"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/categories?post=1338"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mavensecurities.com\/wp-json\/wp\/v2\/tags?post=1338"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}