[time-nuts] verifying synchronization with PPS

[Steve Summit]

This is a different sort of question than what seems to be
discussed here usually, and I apologize if it's wholly off-topic,
but I'm guessing there are some time nuts here who might be able
to give me some pointers.

If I have two boxes with clocks that are supposed to be perfectly
synchronized, and I need to verify this, and they're physically
right next to each other, and they both have PPS outputs, one
way to verify the synchronization would be to compare the two PPS
outputs with a 'scope.  (I'm guessing there's probably a dedicated
instrument out there specialized for the task of comparing two
such PPS signals for frequency, phase and jitter, and if I were
a proper time nut myself I guess I'd know that.)

My specific question concerns the case that one of the boxes is
a computer, for example, a Linux box with time kept using ntpd
or chrony (perhaps also listening to a PPS signal coming in on a
serial port).  But I've never seen a computer with a PPS *output*.

Is this a reasonable thing to be thinking about, or am I going
about it wrong?  How would *you* positively verify synchronization
of such a system?  Me, I'm pursuing this idea because too much
of the time (at least in my own, perhaps parochial experience)
synchronization seems to be "verified" either by saying "Yes,
we configured it properly", or by observing a status output
from ntpd or chrony claiming the requisite synchronization
has been achieved, but in neither case by making a definitive,
independent, external, empirical determination.

(Perhaps PPS is overkill for this situation; perhaps it's the
case that given the inherent inaccuracies of software-based
timekeeping, a software-based query mechanism -- perhaps using
ordinary NTP or PTP protocols -- would be sufficient for
externally assessing synchronization.)

I guess it's not a *completely* unreasonable thing to be thinking
about, because I've found a couple of web pages (for example
https://www.raspberrypi.org/forums/viewtopic.php?t=115554 and
https://github.com/jsln/pps-gen-gpio) describing how to implement
a PPS output under Linux.  And I do realize that trying to
minimize the jitter and latency in this situation (given that
the principal drivers for the hypothetical output are inherently
software-based) presents considerable difficulties.  But taking
all of that into consideration, I'm wondering what others think
of the approach.  Thanks for any comments.