Analyzing WinCC TagLogging Fast vs Slow Data Storage and Archive Segmentation Limits

In SIMATIC PCS 7 and WinCC historical archiving systems, the storage footprint difference between TagLogging Fast (requiring 10 to 15 bytes per record) and TagLogging Slow (requiring approximately 32 bytes per record) stems from database encoding architectures. TagLogging Fast stores high-frequency cycle data (< 1 minute) using a compressed binary stream format, whereas TagLogging Slow stores lower-frequency data (>= 1 minute) in uncompressed relational SQL Server table rows. While WinCC theoretically supports up to 200 segments of 2 GB each (totaling 400 GB), operating near these maximums degrades SQL query performance, making dedicated Process Historian offloading standard practice for long-term archiving.

TagLogging Fast vs TagLogging Slow Binary Architecture

SIMATIC WinCC manages process variable historical archiving through two distinct database subsystems within Microsoft SQL Server:
- TagLogging Fast: Dedicated to high-speed, frequently changing analog and binary variables with acquisition cycles shorter than one minute (e.g. 100 ms, 500 ms, 1 s, 5 s, 10 s). Typical applications include critical pressure transients, flow oscillations, and motor speed curves.
- TagLogging Slow: Dedicated to slow process variables with acquisition intervals equal to or greater than one minute (e.g. 1 min, 5 min, 1 hour, daily totals). Typical applications include tank levels, ambient temperatures, and daily energy consumption totals.

Why Record Footprints Differ: Compressed Streams vs Relational Rows

The substantial difference in memory consumption per archived value is governed by database structure:

TagLogging Fast (10 to 15 Bytes/Value):
- Does not create individual SQL table rows for each logged value.
- Values are packed into continuous binary Large Object (BLOB) stream containers.
- Stores delta timestamps relative to a base block timestamp rather than 8-byte absolute timestamps for each sample.
- Applies loss-less compression algorithms, resulting in an average storage requirement of only 10 to 15 bytes per point.
TagLogging Slow (~32 Bytes/Value):
- Each individual logged value is stored as an independent relational SQL database record.
- Schema per record:
- Absolute Timestamp (DATETIME): 8 bytes
- Tag Identification (TagID INT): 4 bytes
- Variable Value (IEEE 64-bit DOUBLE): 8 bytes
- Quality Code / Status Word (DWORD): 4 bytes
- Primary key and B-tree relational index overhead: ~8 bytes
- Total storage per record amounts to approximately 32 bytes.

Archive Segmentation Limits and the 400 GB Theoretical Boundary

WinCC manages archive storage across rotating circular buffers called segments:
- Segment Size Limit: Individual database segment files (*.mdf / *.ldf) must not exceed 2 GB (the optimal boundary for Microsoft SQL Server page swapping).
- Segment Count Limit: The total number of attached active segments in WinCC Runtime should not exceed 200 segments.
- Theoretical 400 GB Boundary: Multiplying 200 segments by 2 GB yields a theoretical maximum of 400 GB of local storage.
- Performance Reality: In live industrial operation, maintaining 400 GB of attached SQL databases on an active OS Server severely degrades runtime performance. When an operator requests a multi-day trend across multiple tags, SQL Server must traverse dozens of database handles, generating disk I/O bottlenecks and freezing faceplates. For storage requirements beyond 30 to 90 days, Siemens mandates offloading data to SIMATIC Process Historian.

TagLogging Archive Configuration and Performance Matrix

The following table details recommended operational parameters for WinCC TagLogging archives:

Architecture ParameterTagLogging FastTagLogging SlowArchitectural Best PracticeAcquisition Cycle Range< 1 Minute (100 ms to 30 s)>= 1 Minute (1 min to 24 hrs)Assign high-speed loops to Fast; slow loops to SlowAverage Storage per Point10 to 15 Bytes~32 BytesCalculate daily disk growth based on tag acquisition ratesDatabase Storage FormatBinary Compressed BLOB StreamRelational SQL Table RowsFast provides high-speed throughput; Slow enables direct SQL queriesMaximum Single Segment Size2 GB2 GBEnforce 2 GB limit in Tag Logging archive configurationMaximum Total Segments100 to 200 Segments100 to 200 SegmentsKeep total attached segments under 100 for optimal responsivenessRecommended Local Retention7 to 30 Days30 to 90 DaysOffload longer periods to Process Historian

Note: Configure automated backup paths in Archive Configuration to purge detached segments to secondary network storage.

Verification

Verify TagLogging storage consumption and segment rotation:
1. Open Windows Explorer on the OS Server and navigate to <Project_Path>\ArchiveManager\TagLoggingFast\.
2. Inspect active .mdf file sizes; verify that segment files rotate cleanly when reaching the parameterized size (e.g. 1.5 GB to 2.0 GB).
3. In WinCC Explorer, open Tag Logging and inspect Archive Configuration properties; confirm that maximum time periods and disk thresholds are properly configured.
4. Launch WinCC Runtime, open an analog trend window, and confirm that historical data displays across segment transition boundaries without latency.

Limitations and Operational Precautions

Key rules for WinCC historical archiving:
- Never allow the hard drive partition hosting WinCC archives (ArchiveManager) to exceed 85% disk capacity; SQL Server halts database logging when disk space is exhausted.
- Do not run disk defragmentation utilities on active SQL database volumes while WinCC Runtime is processing live data.
- Ensure virus scanners completely exclude the ArchiveManager directory to prevent disk lockups during segment creation.

Engineer FAQ

Can I convert a TagLogging Slow tag to TagLogging Fast?

Yes. In the Tag Logging editor, change the acquisition cycle of the tag to less than one minute, and WinCC will automatically route subsequent data points into the TagLogging Fast database.

Why does WinCC limit individual segment files to 2 GB?

A 2 GB segment file ensures fast SQL Server attachment and detachment times and prevents database table fragmentation during runtime backup operations.

What happens when the maximum total size of all segments is reached?

WinCC automatically detaches and deletes the oldest segment file (First-In, First-Out) unless automated archive swapping to a backup path is configured.