# How Precision Time Protocol is being deployed at Meta – Facebook Engineering

Implementing Precision Time Protocol (PTP) at Meta permits us to synchronize the programs that drive our services right down to nanosecond precision. PTP’s predecessor, Network Time Protocol (NTP), supplied us with millisecond precision, however as we scale to extra superior programs on our technique to constructing the subsequent computing platform, the metaverse and AI, we have to be certain that our servers are retaining time as precisely and exactly as doable. With PTP in place, we’ll have the ability to improve Meta’s applied sciences and applications — from communications and productiveness to leisure, privateness, and safety — for everybody, throughout time zones and all over the world.
The journey to PTP has been years lengthy, as we’ve needed to rethink how each the timekeeping {hardware} and software program function inside our servers and knowledge facilities.
We’re sharing a deep technical dive into our PTP migration and our improvements which have made it doable
Earlier than we dive into the PTP structure, let’s discover a easy use case for terribly correct timing, for the sake of illustration.
Think about a scenario during which a consumer writes knowledge and instantly tries to learn it. In giant distributed programs, likelihood is excessive that the write and the learn will land on totally different back-end nodes.
If the learn is hitting a distant duplicate that doesn’t but have the newest replace, there’s a probability the consumer is not going to see their very own write:
That is annoying on the very least, however extra essential is that that is violating a linearizability assure that enables for interplay with a distributed system in the identical approach as with a single server.
The standard technique to remedy that is to situation a number of reads to totally different replicas and await a quorum resolution. This not solely consumes additional sources but in addition considerably delays the learn due to the lengthy community round-trip delay.
Including exact and dependable timestamps on a again finish and replicas permits us to easily wait till the duplicate catches up with the learn timestamp:
This not solely hastens the learn but in addition saves tons of compute energy.
A vital situation for this design to work is that every one clocks be in sync or that the offset between a clock and the supply of time be recognized. The offset, nevertheless, adjustments due to fixed correction, drifting, or easy temperature variations. For that function, we use the notion of a Window of Uncertainty (WOU), the place we will say with a excessive chance the place the offset is. On this specific instance, the learn must be blocked till the learn timestamp plus WOU.
One may argue that we don’t actually need PTP for that. NTP will just do nice. Properly, we thought that too. However experiments we ran evaluating our state-of-the-art NTP implementation and an early model of PTP confirmed a roughly 100x efficiency distinction:
There are a number of further use instances, together with occasion tracing, cache invalidation, privateness violation detection enhancements, latency compensation within the metaverse, and simultaneous execution in AI, a lot of which can drastically scale back {hardware} capability necessities. This can preserve us busy for years forward.
Now that we’re on the identical web page, let’s see how we deployed PTP at Meta scale.
After a number of reliability and operational evaluations, we landed on a design that may be break up into three major parts: the PTP rack, the community, and the consumer.
Buckle up — we’re going for a deep dive.
This homes the {hardware} and software program that serves time to shoppers; the rack consists of a number of essential parts, every of which has been rigorously chosen and examined.
The GNSS antenna is well one of many least appreciated parts. However that is the place the place time originates, a minimum of on Earth.
We’re striving for nanosecond accuracy. And if the GNSS receiver can’t precisely decide the place, it will be unable to calculate time. We’ve got to strongly think about the signal-to-noise ratio (SNR). A low-quality antenna or obstruction to the open sky can lead to a excessive 3D location customary deviation error. For time to be decided extraordinarily precisely, GNSS receivers ought to enter a so-called time mode, which usually requires a <10m 3D error.
It’s completely important to make sure an open sky and set up a stable stationary antenna. We additionally get to take pleasure in some lovely views:
Whereas we had been testing totally different antenna options, a comparatively new GNSS-over-fiber expertise bought our consideration. It’s free from nearly all disadvantages — it doesn’t conduct electrical energy as a result of it’s powered by a laser through optical fiber, and the sign can journey a number of kilometers with out amplifiers.
Contained in the constructing, it could possibly use pre-existing structured fiber and LC patch panels, which considerably simplifies the distribution of the sign. As well as, the sign delays for optical fiber are effectively outlined at roughly 4.9ns per meter. The one factor left is the delay launched by the direct RF to laser modulation and the optical splitters, that are round 45ns per field.
By conducting checks, we confirmed that the end-to-end antenna delay is deterministic (sometimes about just a few hundred nanoseconds) and might simply be compensated on the Time Equipment aspect.
The Time Equipment is the guts of the timing infrastructure. That is the place time originates from the info heart infrastructure viewpoint. In 2021, we published an article explaining why we developed a brand new Time Equipment and why current options wouldn’t reduce it.
However this was principally within the context of NTP. PTP, however, brings even larger necessities and tighter constraints. Most significantly, we made a dedication to reliably help as much as 1 million shoppers per equipment with out hurting accuracy and precision. To attain this, we took a essential take a look at lots of the conventional parts of the Time Equipment and thought actually exhausting about their reliability and variety.
To guard our infrastructure from a essential bug or a malicious assault,we determined to begin diversification from the supply of time — the Time Card. Final time, we spoke rather a lot concerning the Time Card design and some great benefits of an FPGA-based resolution. Beneath the Open Compute Venture (OCP), we’re collaborating with distributors corresponding to Orolia, Meinberg, Nvidia, Intel, Broadcom, and ADVA, that are all implementing their very own time playing cards, matching the OCP specification.
The Time Card is a essential part that requires particular configuration and monitoring. For this function, we labored with Orolia to develop a disciplining software, known as oscillatord, for various flavors of the Time Playing cards. This has turn into the default software for:
Successfully, the info exported from oscillatord permits us to resolve whether or not the Time Equipment ought to take site visitors or must be drained.
Our final objective is to make protocols corresponding to PTP propagate over the packet community. And if the Time Card is the beating coronary heart of the Time Equipment, the community card is the face. Each time-sensitive PTP packet will get {hardware} timestamped by the NIC. This implies the PTP {Hardware} Clock (PHC) of the NIC have to be precisely disciplined.
If we merely copy the clock values from Time Card to the NIC, utilizing the phc2sys or an analogous software, the accuracy is not going to be practically sufficient. In actual fact, our experiments present that we might simply lose ~1–2 microseconds whereas going by PCIe, CPU, NUMA, and so forth. The efficiency of synchronization over PCIe bus will dramatically enhance with the rising Precision Time Measurement (PTM) expertise, as the event and help for varied peripherals with this functionality is in progress.
For our software, since we use NICs with PPS-in capabilities, we employed ts2phc, which copies clock values at first after which aligns the clock edges based mostly on a pulse per second (PPS) sign. This requires a further cable between the PPS output of the Time Card and the PPS enter of the NIC, as proven within the image beneath.
We consistently monitor offset and ensure it by no means goes out of a ±50ns window between the Time Card and the NIC:
We additionally monitor the PPS-out interface of the NIC to behave as a fail-safe and be certain that we truly know what’s occurring with the PHC on the NIC.
Whereas evaluating totally different preexisting PTP server implementations, we skilled scalability points with each open supply and closed proprietary options, together with the FPGA-accelerated PTP servers we evaluated. At finest, we may get round 50K shoppers per server. At our scale, this implies we must deploy many racks full of those gadgets.
Since PTP’s secret sauce is using {hardware} timestamps, the server implementation doesn’t need to be a extremely optimized C program and even an FPGA-accelerated equipment.
We carried out a scalable PTPv2 unicast PTP server in Go, which we named ptp4u, and open-sourced it on GitHub. With some minor optimizations, we had been in a position to help over 1 million concurrent shoppers per machine, which was independently verified by an IEEE 1588v2 licensed machine.

This was doable by the straightforward however elegant use of channels in Go that allowed us to go subscriptions round between a number of highly effective staff.
As a result of ptp4u runs as a course of on a Linux machine, we routinely get all the advantages, like IPv6 help, firewall, and so forth., at no cost.
The ptp4u server has many configuration choices, permitting it to go dynamically altering parameters corresponding to PTP Clock Accuracy, PTP Clock Class, and a UTC offset — that’s at the moment set to 37 seconds (we’re  looking forward this becoming a constant) — right down to shoppers.
With the intention to incessantly generate these parameters, we carried out a separate service known as c4u, which consistently screens a number of sources of data and compiles the lively config for ptp4u:
This provides us flexibility and reactivity if the surroundings adjustments. For instance, if we lose the GNSS sign on one of many Time Home equipment, we are going to swap the ClockClass to HOLDOVER and shoppers will instantly migrate away from it. Additionally it is calculating ClockAccuracy from many various sources, corresponding to ts2phc synchronization high quality, atomic clock standing, and so forth.
We calculate the UTC offset worth based mostly on the content material of the tzdata bundle as a result of we go Worldwide Atomic Time (TAI) right down to the shoppers.
We needed to ensure our Time Home equipment are consistently and independently assessed by a well-established licensed monitoring machine. Fortunately, we’ve already made a whole lot of progress within the NTP space with Calnex, and we had been ready to use an analogous method to  PTP.
We collaborated with Calnex to take their discipline machine and repurpose it for knowledge heart use, which concerned altering the bodily kind issue and including help for options corresponding to IPv6.
We join the Time Equipment NIC PPS-out to the Calnex Sentinel, which permits us to watch the PHC of the NIC with nanosecond accuracy.

We are going to discover monitoring in nice element in “How we monitor the PTP structure,” beneath.
The PTP protocol helps using each unicast and multicast modes for the transmission of PTP messages. For giant knowledge heart deployments, unicast is most popular over multicast as a result of it considerably simplifies community design and software program necessities.
Let’s check out a typical PTP unicast stream:
A consumer begins the negotiation (requesting unicast transmission). Subsequently, it should ship:
Schematically (only for the illustration), it’ll seem like this:
We initially thought of leveraging boundary clocks in our design. Nevertheless, boundary clocks include a number of disadvantages and issues:
To keep away from this extra complexity, we determined to rely solely on PTP clear clocks.
Clear clocks (TCs) allow shoppers to account for variations in community latency, guaranteeing a way more exact estimation of clock offset. Every knowledge heart swap within the path between consumer and time server experiences the time every PTP packet spends transiting the swap by updating a discipline within the packet payload, the aptly named Correction Subject (CF).
PTP shoppers (additionally known as abnormal clocks, or OCs) calculate community imply path delay and clock offsets to the time servers (grandmaster clocks, or GMs) utilizing 4 timestamps (T1, T2, T3, and T4) and two correction discipline values (CFa and CFb), as proven within the diagram beneath:
To know the affect of only one disabled clear clock on the way in which between consumer and a server, we will look at the logs:
We will see the trail delay explodes, generally even turning into adverse which shouldn’t occur throughout regular operations. This has a dramatic affect on the offset, transferring it from ±100 nanoseconds to -400 microseconds (over 4000 occasions distinction). And the worst factor of all, this offset is not going to even be correct, as a result of the imply path delay calculations are incorrect.
In line with our experiments, fashionable switches with giant buffers can delay packets for as much as a few milliseconds which can lead to a whole lot of microseconds of a path delay calculation error. This can drive the offset spikes and can be clearly seen on the graphs:

The underside line is that operating PTP in datacenters within the absence of TCs results in unpredictable and unaccountable asymmetry within the roundtrip time. And the worst of all – there can be no easy technique to detect this. 500 microseconds might not sound like rather a lot, however when prospects count on a WOU to be a number of microseconds, this will likely result in an SLA violation.
Timestamping the incoming packet is a comparatively previous characteristic supported by the Linux kernel for many years. For instance software program (kernel) timestamps have been utilized by NTP daemons for years. It’s essential to grasp that timestamps aren’t included into the packet payload by default and if required, have to be positioned there by the consumer software.
Studying RX timestamp from the consumer house is a comparatively easy operation. When packet arrives, the community card (or a kernel) will timestamp this occasion and embody the timestamp into the socket control message, which is simple to get together with the packet itself by calling a recvmsg syscall with MSG_ERRQUEUE flag set.
For the TX {Hardware} timestamp it’s a bit extra sophisticated. When sendto syscall is executed it doesn’t result in an instantaneous packet departure and neither to a TX timestamp era. On this case the consumer has to poll the socket till the timestamp is precisely positioned by the kernel. Typically we’ve to attend for a number of milliseconds which naturally limits the ship charge.
{Hardware} timestamps are the key sauce that makes PTP so exact. Many of the fashionable NICs have already got {hardware} timestamps help the place the community card driver populates the corresponding part.
It’s very simple to confirm the help by operating the ethtool command:
It’s nonetheless doable to make use of PTP with software program (kernel) timestamps, however there gained’t be any robust ensures on their high quality, precision, and accuracy.
We evaluated this risk as effectively and even thought of implementing a change within the kernel for “faking” the {hardware} timestamps with software program the place {hardware} timestamps are unavailable. Nevertheless, on a really busy host we noticed the precision of software program timestamps jumped to a whole lot of microseconds and we needed to abandon this concept.
ptp4l is an open supply software program able to performing as each a PTP consumer and a PTP server. Whereas we needed to implement our personal PTP server resolution for efficiency causes, we determined to stay with ptp4l for the consumer use case.
Preliminary checks within the lab revealed that ptp4l can present glorious synchronization high quality out of the field and align time on the PHCs within the native community right down to tens of nanoseconds.
Nevertheless, as we began to scale up our setup some points began to come up.
In a single specific instance we began to note occasional “spikes” within the offset. After a deep dive we recognized basic {hardware} limitations of one of the vital fashionable NICs in the marketplace:
This in the end led to the authentic timestamps being displaced by timestamps coming from different packets. However what made issues rather a lot worse – the NIC driver tried to be overly intelligent and positioned the software program timestamps within the {hardware} timestamp part of the socket management message with out telling anybody.
It’s a basic {hardware} limitation affecting a big portion of the fleet which is inconceivable to repair.
We needed to implement an offset outliers filter, which modified the habits of PI servo and made it stateful. It resulted in occasional outliers being discarded and the imply frequency set throughout the micro-holdover:
If not for this filter, ptp4l would have steered PHC frequency actually excessive, which might lead to a number of seconds of oscillation and dangerous high quality within the Window of Uncertainty we generate from it.
One other situation arose from the design of BMCA. The aim of this algorithm is to pick out the very best Time Equipment when there  are a number of to select from within the ptp4l.conf. It does by evaluating  a number of attributes equipped by Time Servers in Announce messages:
The issue manifests itself when all aforementioned attributes are the identical. BMCA makes use of Time ApplianceMAC tackle because the tiebreaker which suggests beneath regular working situations one Time Server will entice all consumer site visitors.
To fight this, we launched a so-called “sharding” with totally different PTP shoppers being allotted to totally different sub-groups of Time Home equipment from the complete pool.
This solely partially addressed the problem with one server in every subgroup taking the complete load for that grouping. The answer was to allow shoppers to precise a choice, and so we launched Priority3 into the choice standards simply above the MAC tackle tiebreaker.  Which means shoppers configured to make use of the identical Time Home equipment can choose totally different servers.
Consumer 1:
[unicast_master_table]
UDPv6 time_server1 1
UDPv6 time_server2 2
UDPv6 time_server3 3
Consumer 2:
[unicast_master_table]
UDPv6 time_server2 1
UDPv6 time_server3 2
UDPv6 time_server1 3
This ensures we will distribute load evenly throughout all Time Home equipment beneath regular working situations.
One other main problem we confronted was guaranteeing PTP labored with multi-host NICs – a number of hosts sharing the identical bodily community interface and due to this fact a single PHC. Nevertheless, ptp4l has no data of this and tries to self-discipline the PHC like there are not any different neighbors.
Some NIC producers developed a so-called “free operating” mode the place ptp4l is simply  disciplining the components contained in the kernel driver. The precise PHC just isn’t affected and retains operating free. This mode ends in a barely worse precision, but it surely’s utterly clear to ptp4l
Different NIC producers solely help a “actual time clock” mode, when the primary host to seize the lock truly disciplines the PHC. The benefit here’s a extra exact calibration and better high quality holdover, but it surely results in a separate situation with ptp4l operating on the opposite hosts utilizing the identical NIC as makes an attempt to tune PHC frequency haven’t any affect, resulting in inaccurate clock offset and frequency calculations.
To explain the datacenter configuration, we’ve developed and published a PTP profile, which displays the aforementioned edge instances and lots of extra.
We’re evaluating the potential for utilizing another PTP consumer. Our major standards are:
We’re evaluating the Timebeat PTP consumer and, to this point, it appears to be like very promising.
Within the PTP protocol, it doesn’t actually matter what time we propagate so long as we go a UTC offset right down to the shoppers. In our case, it’s Worldwide Atomic Time (TAI), however some individuals might select UTC. We like to consider the time we offer as a repeatedly incrementing counter.
At this level we aren’t disciplining the system clock and ptp4l is solely used to self-discipline the NIC’s PHC.
Synchronizing PHCs throughout the fleet of servers is sweet, but it surely’s of no profit until there’s a technique to learn and manipulate these numbers on the consumer.
For this function, we developed a easy and light-weight API known as fbclock that gathers info from PHC and ptp4l and exposes simple digestible Window Of Uncertainty info:

By a really environment friendly ioctl PTP_SYS_OFFSET_EXTENDED, fbclock will get a present timestamps from the PHC, newest knowledge from ptp4l after which applies math components to calculate the Window Of Uncertainty (WOU):
As you might even see, the API doesn’t return the present time (aka time.Now()). As a substitute, it returns a window of time which incorporates the precise time with a really excessive diploma of chance On this specific instance, we all know our Window Of Uncertainty is 694 nanoseconds and the time is between (TAI) Thursday June 02 2022 17:44:08:711023134 and Thursday June 02 2022 17:44:08:711023828.
This method permits prospects to attend till the interval is handed to make sure precise transaction ordering.
Measuring the precision of the time or (Window Of Uncertainty) signifies that alongside the delivered time worth, a window (a plus/minus worth) is offered that’s assured to incorporate the true time to a excessive stage of certainty.
How sure we have to be is decided by how essential it’s that the time be appropriate and that is pushed by the particular software.
In our case, this certainty must be higher than 99.9999% (6-9s). At this stage of reliability you may count on lower than 1 error in 1,000,000 measurements.
The error charge estimation makes use of remark of the historical past of the info (histogram) to suit a chance distribution operate (PDF). From the chance distribution operate one can calculate the variance (take a root sq. and get the usual deviation) and from there it will likely be easy multiplication to get to the estimation of the distribution based mostly on its worth.

Under is a histogram taken from the offset measurement from ptp4l operating on the abnormal clock.

To estimate the entire variance (E2E) it’s essential to know the variance of the time error accrued by the point server all the way in which to the top node NIC. This contains GNSS, atomic clock, and Time Card PHC to NIC PHC (ts2phc). The producer gives the GNSS error variance. Within the case of the UBX-F9T it’s about 12 nanoseconds. For the atomic clock the worth relies on the disciplining threshold that we’ve set. The tighter the disciplining threshold, the smaller offset variance however decrease holdover efficiency. On the time of operating this experiment, the error variance of the atomic clock has been measured to 43ns (customary deviation, std). Lastly, the software ts2phc will increase the variance by 30ns (std) leading to a complete variance of 52ns.
The noticed outcomes matches the calculated variance obtained by the “Sum of Variance Legislation.”
$\large \text{Var}\sum_{i=1}^{n}\chi _{i} = \sum_{i=1}^{n}\text{Var}(\chi _{i})$
In line with the sum of variance regulation, all we have to do is so as to add all of the variance. In our case, we all know that the entire observer E2E error (measured through the Calnex Sentinel) is about 92ns.
On the opposite fingers for our estimation, we will have the next:
Estimated E2E Variance = [GNSS Variance + MAC Variance + ts2phc Variance] + [PTP4L Offset Variance] = [Time Server Variance] + [Ordinary Clock Variance]
Plugging within the values:
Estimated E2E Variance = (12ns 2) + (43ns2) + (52ns2) + (61ns2) = 8418, which corresponds to 91.7ns
These outcomes present that by propagating the error variance down the clock tree, the E2E error variance may be estimated with a superb accuracy. The E2E error variance can be utilized to calculate the Window Of Uncertainty (WOU) based mostly on the next desk.
Merely, by multiplying the estimated E2E error variance in 4.745 we will estimate the Window Of Uncertainty for the chance of 6-9s.
For our given system the chance of 6-9s is about 92ns x 4.745 = 436ns
Which means given a reported time by PTP, contemplating a window measurement of 436ns round worth ensures to incorporate the true time by a confidence of over 99.9999%.
Whereas all of the above appears to be like logical and nice, there’s a large assumption there. The belief is that the connection to the open time server (OTS) is accessible, and all the pieces is in regular operation mode. Lots of issues can go incorrect such because the OTS taking place, swap taking place, Sync messages not behaving as they’re alleged to, one thing in between decides to get up the on-calls and so forth. In such a scenario the error sure calculation ought to enter the holdover mode. The identical issues apply to the OTS when GNSS is down. In such a scenario the system will improve the Window Of Uncertainty based mostly on a compound charge. The speed can be estimated based mostly on the soundness of the oscillator (scrolling variance) throughout regular operations. On the OTS the compound charge will get adjusted by the correct telemetry monitoring of the system (Temperature, Vibration, and so forth). There’s a honest quantity of labor by way of calibrating coefficients right here and attending to the very best consequence and we’re nonetheless engaged on these nice tunings.
Through the durations of community synchronization availability, the servo is continually adjusting the frequency of the native clock on the consumer aspect (assuming the preliminary stepping resulted in convergence). A break within the community synchronization (from shedding connection to the time server or the time server itself taking place) will depart the servo with a final frequency correction worth. Consequently, such worth just isn’t aimed to be an estimation of precision of the native clock however as a substitute a short lived frequency adjustment to cut back the time error (offset) measured between the cline and the time server.
Subsequently, it’s essential to first account for synchronization loss durations and use the very best estimation of frequency correction (normally, the scrolling common of earlier correction values) and second, account for the error sure improve by wanting on the final correction worth and evaluating it with the scrolling common of earlier correction values.
Monitoring is likely one of the most essential elements of the PTP structure. Because of the nature and affect of the service, we’ve spent fairly a little bit of time engaged on the tooling.
We labored with the Calnex workforce to create the Sentinel HTTP API, which permits us to handle, configure, and export knowledge from the machine. At Meta, we created and open-sourced an API command line software permitting human and script pleasant interactions.
Utilizing Calnex Sentinel 2.0 we’re in a position to monitor three major metrics per time equipment — NTP, PTP, and PPS.

This permits us to inform engineers about any situation with the home equipment and exactly detect the place the issue is.
For instance, on this case each PTP and PPS monitoring resorts in a roughly lower than 100 nanosecond variation over 24 hours when NTP stays inside 8 microseconds.
With the intention to monitor our setup, we carried out and open-sourced a software known as ptpcheck. It has many various subcommands, however essentially the most attention-grabbing are the next:
Consumer subcommand gives an total standing of a ptp consumer. It experiences the time of receipt of final Sync message, clock offset to the chosen time server, imply path delay, and different useful info:
Consumer subcommand that enables querying of an fbclock API and getting a present Window of Uncertainty:
Chrony-style consumer monitoring, permits to see all Time Servers configured within the consumer configuration file, their standing, and high quality of time.
Server subcommand, permits to learn a abstract from the Time Card.
For instance, we will see that the final correction on the Time Card was simply 1 nanosecond.
This subcommand permits us to get a distinction between any two PHCs:
On this specific case the distinction between Time Card and a NIC on a server is -15 nanoseconds.
It’s good to set off monitoring periodically or on-demand, however we wish to go even additional. We wish to know what the consumer is definitely experiencing. To this finish, we embedded a number of buckets proper inside the fbclock API based mostly on atomic counters, which increment each time the consumer makes a name to an API:
This permits us to obviously see when the consumer experiences a problem — and sometimes earlier than the consumer even notices it.
PTP protocol (and ptp4l particularly) don’t have a quorum choice course of (not like NTP and chrony). This implies the consumer picks and trusts the Time Server based mostly on the knowledge supplied through Announce messages. That is true even when the Time Server itself is incorrect.
For such conditions, we’ve carried out a final line of protection known as a linearizability examine.
Think about a scenario during which a consumer is configured to make use of three time servers and the consumer is subscribed to a defective Time Server (e.g., Time Server 2):
On this scenario, the PTP consumer will suppose all the pieces is okay, however the info it gives to the applying consuming time can be incorrect, because the Window of Uncertainty can be shifted and due to this fact inaccurate.
To fight this, in parallel, the fbclock establishes communication with the remaining time servers and compares the outcomes. If nearly all of the offsets are excessive, this implies the server our consumer follows is the outlier and the consumer just isn’t linearizable, even when synchronization between Time Server 2 and the consumer is ideal.
We consider PTP will turn into the usual for retaining time in laptop networks within the coming a long time. That’s why we’re deploying it on an unprecedented scale. We’ve needed to take a essential take a look at our complete infrastructure stack — from the GNSS antenna right down to the consumer API — and in lots of instances we’ve even rebuilt issues from scratch.
As we proceed our rollout of PTP, we hope extra distributors who produce networking tools will reap the benefits of our work to assist convey new tools that helps PTP to the business. We’ve open-sourced most of our work, from our supply code to our {hardware}, and we hope the business will be a part of us in bringing PTP to the world. All this has all been accomplished within the title of boosting the efficiency and reliability of the present options, but in addition with a watch towards opening up new merchandise, providers, and options sooner or later.
We wish to thank everybody concerned on this endeavor, from Meta’s inner groups to distributors and producers collaborating with us. Particular thanks goes to Andrei Lukovenko, who related time lovers.
This journey is only one % completed.
Meta believes in constructing neighborhood by open supply expertise. Discover our newest initiatives in Synthetic Intelligence, Knowledge Infrastructure, Improvement Instruments, Entrance Finish, Languages, Platforms, Safety, Digital Actuality, and extra.
Engineering at Meta is a technical information useful resource for engineers concerned with how we remedy large-scale technical challenges at Meta.
To assist personalize content material, tailor and measure adverts, and supply a safer expertise, we use cookies. By clicking or navigating the positioning, you agree to permit our assortment of data on and off Fb by cookies. Be taught extra, together with about obtainable controls: Cookies Policy