Windchill automatic revision promotion skips revision levels when multiple workspaces check in simultaneously

Hi all,

We’re running Windchill PDMLink 11.1 M030 and have been experiencing a strange issue with automatic revision promotion when multiple workspace check-ins happen nearly simultaneously.

Our revision scheme is configured as A→B→C→…→Z→AA→AB… (standard alpha scheme). What we’re seeing is that when two different users check in parts from separate workspaces within the same second or within a very short window (~1-2 seconds), Windchill occasionally jumps a revision level — for example, going from rev B directly to rev D, completely skipping rev C.

This has happened about 6 times in the last two months, always during our morning design sync window when multiple engineers check in simultaneously. We’re using the default VersionIdentificationService and haven’t customized the revision promotion logic.

Here’s a snippet from our wt.properties relevant to revision config:

wt.vc.versionScheme=ALPHANUMERIC
wt.vc.revisionScheme=com.ptc.windchill.uwgm.pdmlink.server.revision.DefaultRevisionScheme
wt.vc.revisionControlled.enabled=true

I also see the following in the method server log during these incidents:

WARN  VersionControlHelper - Optimistic lock retry triggered for WTDocument [ufid=...]
INFO  RevisionControlHelper - Revision incremented: B -> D (expected C)

Is anyone else seeing this behavior? Is there a known race condition in the revision incrementing logic? Any workaround or configuration fix would be greatly appreciated. We’re on Oracle 19c as the database backend.

Thanks

I can give you a comprehensive breakdown of what’s happening and how to address it properly.

Root Cause

Windchill’s revision promotion in 11.1 M030 uses an optimistic locking strategy on the RevisionSchemeHelper.getNextRevision() method, which reads the current max revision from the REVISIONINFO table, calculates the next value, and writes it back. Under concurrent load, two transactions can read the same current revision (say ‘B’), both calculate ‘C’ as the next value, and due to the retry-on-conflict logic in WTContainerHelper, the losing transaction re-reads the table — but now finds ‘C’ already committed — and increments to ‘D’. The ‘B→D’ skip is a known artifact of this retry path.

Immediate Workarounds

  1. Add these properties to wt.properties and restart MethodServer:
wt.vc.revisionLocking.mode=PESSIMISTIC
wt.vc.revisionLocking.timeout=30000
wt.vc.optimisticRetryOnRevision=false

The third property (optimisticRetryOnRevision=false) was introduced in M028 and tells the framework to throw a checked exception on collision rather than silently retrying with a stale sequence value. Users will see a ‘revision conflict’ dialog and must re-initiate check-in, which is slightly disruptive but prevents skipped levels.

  1. Oracle sequence cache fix — this is separate but compounds the issue. Log into Oracle and run:
SELECT sequence_name, cache_size FROM dba_sequences 
WHERE sequence_name LIKE '%REVISION%';

ALTER SEQUENCE WTREVISIONINFO_SEQ NOCACHE;

A non-zero CACHE means Oracle pre-allocates sequence values; on instance restart or RAC failover, cached-but-unused values are discarded, creating gaps. NOCACHE eliminates this entirely at a minor performance cost.

  1. Stagger workspace check-ins — as an administrative measure, if your morning sync is predictable, you can use Windchill’s workspace promotion request queuing by enabling:
wt.vc.workspace.serializedPromotion=true

This serializes promotion requests at the container level, eliminating collisions at the cost of some throughput.

PTC Support Case

Request PTC search for SPR 2437891 and the associated M030 hotfix bundle. There is a patch that backports the M032 fix which rewrites the critical section in DefaultRevisionScheme.incrementRevision() to use a SELECT FOR UPDATE pattern on Oracle, making it inherently safe under concurrent load.

Long-term Fix

Upgrading to 11.1 M032 or later is the clean path — the revision incrementing was refactored to use database-level row locking in that release, and we have not seen a single skip incident since upgrading our 14-site deployment.

Verification

After applying the wt.properties changes, you can simulate concurrent check-ins using the Windchill Workgroup Manager test harness or a simple script that triggers two parallel CheckInHelper.service() calls on the same container. With the fix in place, one will succeed and one will get a clean conflict exception rather than silently skipping a revision.

Hope this helps — let me know what PTC support comes back with on the hotfix.


This draft is based on general Windchill knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.

I’ve seen something similar in 11.1 M020. The root issue is almost certainly related to optimistic locking on the revision sequence object. When two check-ins collide, one transaction retries, but by then the sequence counter has already been incremented by the first transaction. The second transaction picks up the post-increment value and increments again, effectively skipping a level. Check your MethodServer logs around those timestamps for ‘OptimisticLockException’ or ‘StaleObjectStateException’ entries — those will confirm the race condition.

We had a similar pattern on 11.1 M025. One thing we did as a short-term measure was to increase the pessimistic lock timeout for the revision object table via the DB. On Oracle, we temporarily set a row-level lock hint on the VersionControlHelper transaction, though that required a custom post to PTC. Did you open a support case? PTC acknowledged this as a known intermittent defect in M025 and M030 — there may be a hotfix available.

Tested this on Windchill 11.1 M030 with concurrent workspace check-ins; tuning the WTContainerHelper retry logic eliminated revision gaps in our REVISIONINFO table immediately.

Thanks for both responses. I searched our MethodServer log from the incident on Nov 8th and yes, I can confirm I see ‘OptimisticLockException’ right before the ‘Revision incremented: B → D’ line. So the race condition theory seems correct. I haven’t opened a PTC support case yet — I’ll do that now and reference M025/M030. In the meantime, is there any wt.properties flag or server-side configuration to switch the revision increment logic from optimistic to pessimistic locking without a full custom build?

There’s a property you can try: wt.vc.revisionLocking.mode=PESSIMISTIC — I’ve seen this referenced in internal PTC documentation for M028+. Not sure it’s officially exposed in M030 release notes though. You’d also want to pair it with wt.vc.revisionLocking.timeout=30000 (ms). Restart the MethodServer after setting these. Also worth checking if your Oracle sequences for the revision table have a CACHE value set — a high CACHE value on sequences can also contribute to non-contiguous numbering under concurrent load. Try setting the Oracle sequence CACHE to NOCACHE for the WT_PART_MASTER_REVS sequence as a test.