Arista Networks, Inc.

Tellabs Operations, Inc.

Sebastian Sapa

Duncan Stuart Ritchie

Christopher Elisha Neilson

Praveen Madhav

Chakravarthi S Chigurapati

Hugh Weber Holbrook

Pawan Uberoy

Roman Olegovich Chertov

Somnath Mani

Peter Edwards

Eric Secules

Jonathan Antusiak

Allan Drew Clarke

Simon Francis Capper

Stuart Ritchie

Stephanie Elaine Fung

Anirban Sinha

Ronan Mac Fhlannchadha

Vijay Varma Galbaransingh

Francois Guy Maurice Ripault

Travis Frederick Brown

Peter John Fordham

The present disclosure is directed to a shared first-in-first-out (FIFO) queue architecture in a computing device, such as a network device, that allows lock-free, concurrent access to a writer process (writer) and one or more reader processes (readers). The writer enqueues information provided to the computing device. One or more readers dequeue the information and process the information. A queue manager provides an interface to the shared queue to allow the writer to push data onto the queue and readers to access the queue; e.g., peek and pop the queue. The readers inform the writer when they perform dequeue operations so that the writer knows when to age out queue entries for deletion from the queue.

Sharing state information using shared memory

A network device includes an application programming interface (API) to access (read/write) network device configuration and status. For read requests, the API services the request by reading one or more internal data stores to read out the requested data without first reading a data tree that stores network device configuration and state. For write requests, the API services the request by writing data to one or more internal data stores, without first writing to a data tree that stores network device configuration and state.

Sharded model for configuration management and status retrieval

A method and apparatus of a network device that allocates a shared memory buffer for an object is described. In an exemplary embodiment, the network device receives an allocation request for the shared memory buffer for the object. In addition, the network device allocates the shared memory buffer from shared memory of a network device, where the shared memory buffer is accessible by a writer and a plurality of readers. The network device further returns a writer pointer to the writer, where the writer pointer references a base address of the shared memory buffer. Furthermore, the network device stores the object in the shared memory buffer, wherein the writer accesses the shared memory using the writer pointer. The network device further shares the writer pointer with at least a first reader of the plurality of readers. The network device additionally translates the base address of the shared memory buffer to a reader pointer, where the reader pointer is expressed in a memory space of the first reader.

Shared memory allocator with child process

Systems and methods for the dynamic mapping of network element data between data models in network devices are disclosed. In particular, a marked-up native data model can be processed to create a mapping schema file based on the markup included in the native data model. This mapping schema file may define mappings between elements of the native data model and corresponding elements of an external data model. The mapping schema file can then be used to dynamically map network element data from the native data model to the external data model, such as when responding to requests for network element data associated with the mapped elements.

Method and system for data model mapping for network management

Methods and apparatus for enabling detection of configuration changes in a network device. One method uses a configuration counter in a system database of the network device. In response to an atomic submission of CLI commands to a configuration agent and the storing of the corresponding configuration in a system database, the configuration counter is incremented. An OpenConfig module maintains an expected value of the configuration counter and, upon completion of its own command submissions, compares the expected value to the value in the configuration counter. If the two values do not match, it indicates that the configuration counter in the system database has been incremented as a result of a configuration change from a source other than the OpenConfig module. A configuration client can then be notified of the configuration change so that it can revert the configuration to a desired configuration.

Detecting configuration collisions between multiple configuration clients

A method and apparatus of a device that grows and/or shrinks a table that is shared between a writer and a plurality of readers is described. In an exemplary embodiment, a device receives an entry to be added to the shared table. In response to receiving the entry, the device remaps shared table to add a new storage segment to the shared table. The device further adds the entry to the shared table, where the entry is stored in the new storage segment. In addition, the device updates a shared table characteristic to indicate that the shared table has changed. The device further shrinks the shared table by remapping the table to remove a segment of the table.

Growing dynamic shared memory hash table

Dynamic type resolution for shared memory

Systems and methods for implementing polymorphic allocators in an operating system are disclosed. An illustrative method includes a method of allocating memory space in a memory by creating a first allocator. In response to receiving a first request to allocate memory space in the memory for a data buffer instance using the first allocator, the method allocates one or more pages of a first region in the memory by populating one or more entries of an allocator table. The one or more entries of the allocator table correspond to the one or more pages of the first region. The entries of the allocator table are indexed by page indexes corresponding to page addresses identifying the pages of the first region in the memory. Each of the populated entries of the allocator table includes a specific allocator identifier identifying a corresponding allocator to that entry.

Polymorphic allocators in an operating system

Systems and methods for creating a new entry in a hierarchical state data structure with object entries is disclosed. The method includes allocating a shared memory buffer for a new entry in a shared memory. A request to create the new entry for a child object in a hierarchical state data structure in the shared memory is received. The new entry is to span at least one shared memory buffer uniquely identifiable in a location of the shared memory. The child object is a logical representation of a state of a system. In response to a request for an allocation of a shared memory buffer within a region of the shared memory for the new entry, a location identifier corresponding to a location of a parent entry holding a parent object to the child object in the hierarchical state data structure of an allocated region is received. The child object is created in the shared memory buffer for the new entry, and the new entry is available for concurrent access by one or more readers of the shared memory.

Lock-free method of transmitting hierarchical collections through shared memory

Systems and methods for processing memory address spaces corresponding to a shared memory are disclosed. After a writer restart process, pre-restart writer pointers of a pre-restart writer addressable space in the shared memory are replaced with corresponding location independent pointers. A writer pointer translation table is rebuilt in the shared memory to replace an association of modified pre-restart writer pointers and pre-restart translation base pointers based on the pre-restart writer pointers, respectively, with an association of modified post-restart writer pointers and post-restart translation base pointers based on post-restart writer pointers, respectively. After the writer pointer translation table is rebuilt, the location independent pointers are replaced with post-restart writer pointers in the shared memory, respectively, and the post-restart writer pointers are stored in the shared memory for access by one or more readers of the shared memory.

Restartable, lock-free concurrent shared memory state with pointers

Techniques are described herein for managing data structure groups. Such techniques may include providing to a data structure group, by a reader, a plurality of data structure identifiers including a first data structure identifier and a second data structure identifier; mounting, by the data structure group, a first data structure identified by the first data structure identifier and including a first instance identifier; mounting, by the data structure group, a second data structure identified by the second data structure identifier and including a second instance identifier; making a first determination that the first data structure and the second data structure are mounted; making a second determination that the first instance identifier and the second instance identifier match; and marking, based on the first determination and the second determination, the data structure group as ready-to-read.

System and method for cohesive shared multi-data structure lifecycle

System and method of a dynamic shared memory hash table with notifications

System and method of a shared memory allocator

A method and apparatus of a device that includes a shared memory hash table that notifies one or more readers of changes to the shared memory hash table is described. In an exemplary embodiment, a device receives a key that corresponds to the value, where the key used to retrieve the value form the shared memory hash table and the shared memory hash table is written to by a writer and read from by a plurality of readers. In addition, the device retrieves an index from a local values table, where the local values table stores a plurality of indices for one of the plurality of readers and the index is an index into an entry in the shared memory hash table. The device further retrieves the value from the shared memory hash table using the index.

System and method of a shared memory hash table with notifications and reduced memory utilization

A method and/or network system is able to perform an in-service software upgrade ('ISSU') using virtualization technology while ongoing network service is maintained. After receipt of an upgrade signal such as a command of software upgrade, a new or second virtual machine ('VM') is created in response to the upgrade signal. After downloading the new version of program to the second VM while maintaining the first version of program running on the first VM, the process for providing network management begins to migrate from the first version of program to the new version of program. The process simultaneously facilitates ISSU for a data-path module such as a line card to convert from the previous version of software to the new version of the software.

Growing community of inventors

Vancouver, Canada

Sebastian Sapa