hash stringlengths 32 32 | doc_id stringlengths 5 12 | section stringlengths 5 1.47k | content stringlengths 0 6.67M |
|---|---|---|---|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.1.1 Description
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.1.1.1 Description of tools
| For editing ODT documents, LibreOffice is a natural choice, however it is by no means the only option. Here is a short and not exhaustive list of such tools with short summaries of their strengths:
- LibreOffice Writer: This is arguably the most popular and comprehensive ODT editor. It's free, open-source, and cross-platform.
- Google Docs: While primarily a web-based editor, Google Docs offers good support for opening, editing, and saving ODT files.
- Microsoft Word: Microsoft Word has some support for ODT, but the compatibility isn't always perfect (e.g. Track Changes aren’t supported, i.e. when you save the Word document in .odt format, all changes are accepted), and some formatting may be lost or altered. It's generally better to use a dedicated ODT editor if you're working extensively with the format.
- Calligra Words: Part of the Calligra Suite, this is a free and open-source option, particularly popular in the Linux community.
As for automation, there are libraries available for OpenDocument automation, with the two most promising ones being:
- LibreOffice API available for Java and C++
- odfpy for Python
Furthermore, since OpenDocument is a standardized XML-based format, one can always use XML manipulation libraries (which are many and some of them are extremely powerful) to literally do anything with OpenDocument files.
LibreOffice has a certification program and provides a list of certified developers who can be commissioned to develop:
- New LibreOffice features
- Tools for/based-on LibreOffice
- Various automation scripts
With this, various automation tools can be developed for delegates, rapporteurs and MCC. It is important to note that it is not only possible to develop tools for ODT, but since it is an open-source tool, it is possible to enhance LibreOffice itself to support 3GPP-specific functionality.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2 Proposal #2 Git for Version Control
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1 Description
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.0 Overview
| Git (https://git-scm.org) is an open-source distributed version control system, which tracks changes to files and enables collaboration.
Distributed means that every user can download and update a full copy of the repository, including files and their history locally (not just the current files, but also the full change history, also known as a commit graph). Changes are made and recorded locally and later synchronized with other copies using network operations (push, pull, fetch).
We can distinguish four areas in git workflow (see Figure 6.2.1.0-1):
- Remote repository - A copy of the project hosted on a server (e.g., 3GPP Forge, GitLab, or an SSH/git server) that acts as a shared central repository for collaborators to push to and fetch from. It stores the full history and interaction with it is done over the network.
- Local repository - The complete Git repository on your machine (.git directory) containing the full commit history and references. The user can commit, branch, and inspect history offline.
- Working directory (working tree) - The user edits the checked-out files locally, derived from a commit in the local repository. Changes in this area are unrecorded until staged and committed
- Staging area (index) - A temporary area where user place selected changes (with git add command) to build the next commit, letting user control exactly which modifications become part of that commit.
Figure 6.2.1.0-1: Git workflow areas and basic procedures
Editor's Note: It is FFS how the databases described in this clause relate to the existing databases (tdoc database, CR database, and the meeting report), and what the impacts are on the processes that interact with these existing databases.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1 Description of tools
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1.0 Overview
| The following are basic git commands for creating and saving changes (see Figure 6.2.1.0-1):
- git clone - Create a full local copy of a remote repository, it contains both file and changes history. Cloning a repository is the action of downloading the repository from the remote server.
- git fetch - Download changes history (commits) and references from a remote repository into local repository without changing working files.
- git pull - Fetch changes from remote repository and merge them into working copy. Pull is different from fetch in that fetch simply downloads all the commits and branches, while pull also replays the changes of those commits onto the local copy of the repository.
- git add - Stage changes (new / modified / deleted files) to prepare them for a commit to local repository. Prior to committing changes, the files which should be taken as part of the commit must be identified.
- git commit - Record staged changes as a new local snapshot in the repository history. Commit saves the changes as a difference between an original version and a revised version instead of saving the full file each time.
- git push - Send local changes (commits) to a remote repository, so others can access them. Pushing is the same as uploading.
- git branch - Create, list, or switch between independent lines of development (isolated commit histories).
- git checkout - Switch between branches or commits. The checkout command can take a branch name, tag name, or commit hash as input.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1.1 Git commit
| The Git commit command records a snapshot of the project’s staged changes, capturing the state of the codebase at a particular point of time. Each commit consists of following elements:
- Metadata - Includes author, committer, message, timestamps, and a unique identifier called a SHA hash.
- Commit Message - Describes what the commit changes and why. This is crucial for understanding project history.
- Parent Reference - Points to the previous commit(s), allowing Git to track project history as a directed acyclic graph.
The Git commit message can be standardized using a pre-defined template. It can be achieved with Conventional Commits, which is a specification for writing consistent and meaningful commit messages in Git. Its goal is to make project history easier to read, automate changelogs, and enable semantic versioning.
Commit message can be composed of following elements (Figure 6.2.1.1.1-1):
- Type - Nature of the change (feat, fix, docs, style, refactor, test, chore)
- Scope - Area of the codebase affected
- Subject - Short summary of the change
- Body - Detailed explanation, motivation, or context
- Footer - References to issues, breaking changes, or metadata
Figure 6.2.1.1.1-1 Example commit message structure
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1.2 Git branching
| Git branching is essential for managing projects efficiently in collaborative and feature-driven development workflows. Key aspects of branching include:
- Creating independent lines of development
- Isolate changes and work on new features, bug fixes, or experiments without affecting the main codebase
- Enable collaboration by allowing multiple users to work on different branches
- Maintain stability in the main branch
Git merge feature is used to combine commits from one branch into another. Any conflicts that occur during merge are resolved manually and recorded in the resulting commit. In the example of Figure 6.2.1.1.2-1, we start with the main branch, which contained v18.1.0. A branch called v18.2.0 was created to aggregate accepted changes to v18.1.0. Two CRs are shown in the diagram: CR-123 and CR-456. Both CRs were created from the same initial version, corresponding to v18.1.0 and the changes imposed by each CR were written independently from one another, enabling parallel work. Each CR went through a few revisions, i.e., CR-456:1 and CR-456:2 prior to being finally accepted and merged into the v18.2.0 branch. Once both CRs were merged, the v18.2.0 branch was merged into the main branch, becoming the latest version of the release.
Figure 6.2.1.1.2-1: Example git branching and merging
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1.3 Git history
| Git history provides detailed information about every single change introduced by commits, including:
- Commit Details: Includes commit hashes, messages, authors, dates, and timestamps.
- Changes to Files: Tracks what changes were made to specific files over time.
- Branch Contributions: Identifies changes introduced by specific branches.
- Author Contributions: Shows who made specific changes and when.
- Line-Level History: Provides details on the last modification for each line in a file.
- Time-Based Changes: Filters commits based on specific timeframes (e.g., last two days).
- Searchable Commit Messages: Allows searching for commits related to particular functionality or keywords.
Git history can be visualized using git commit graph (Figure 6.2.1.1.3-1), which is the directed acyclic graph (DAG) that represents commits and their parent relationships in a Git repository. Visualizations called "git graphs" expose the repository history and topology. Key information a git graph provides:
- Commits as nodes: each node is a commit (hash), with author, date, and commit message.
- Parent/child edges: arrows/lines show parent relationships.
- Branch and tag labels: which commits are pointed to by refs (branch names, tags).
- Branching and merging structure: where branches diverged and were merged back.
- Topology vs time: order can be topological (ancestry) or chronological; visualization usually combines both.
- Reachability and history context: which commits are reachable from which branches.
Figure 6.2.1.1.3-1: Example git graph visualization in Gitlab (source docs.gitlab.com)
Git CLI commands used to browse repository history:
- git log - Displays the commit history for current branch.
- git diff - Compare changes between different states of a repository
- git blame - Displays line-by-line history of a file, showing the author, date, and commit hash for each line.
- git show - Displays detailed information about a specific commit, including the commit message and diff of changes.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.1.4 Git GUI tools
| Git itself is a CLI (Command Line Interface) based tool, but it is also integrated in many existing GUI (Graphical User Interface) tools. Because Git repositories are decentralized, it can be completely up to user preference which tools to use. Some examples of Git tools include:
- Built-in GUIs:
- git-gui — Simple official Tcl/Tk GUI shipped with Git for staging, committing, and basic history browsing.
- gitk — Official repository history browser/visualizer that ships with Git for commit graph inspection.
- Windows Git GUI (installed with Git for Windows) — Lightweight GUI wrapper for common Git tasks on Windows.
- Server / hosted tools:
- GitLab — Full DevOps platform with repo hosting, CI/CD, issue tracking, merge requests and web-based file/PR UI. This is the same platform used by 3GPP Forge and ETSI Forge.
- GitHub — Widely used hosted Git service with pull requests, code review, Actions CI, and web-based file and diff editors.
- IDE integrations
- Visual Studio Code — Built-in Source Control view and many Git extensions for staging, branching, diffs and merges.
- JetBrains IDEs (IntelliJ, PyCharm) — Integrated VCS tools with GUI for commits, branches, history, and conflict resolution.
- Visual Studio — Integrated Git client and GitHub/GitLab extensions for full repo workflows inside the IDE.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2 Description of repository structure and branching
| This section describes the physical structure of the repository and the branches required to track releases, the effect of Git operations on the repository structure, and how CRs become part of the specification.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.1 Structure
| A repository would be created for each specification, e.g., TS 38.300 and TS 38.331 would be kept in distinct repositories. The reason for maintaining separate repositories is to cleanly associate CRs with a specification as is done today and to enable the individual tracking of versions of releases. When exploring a specification repository, it can be guaranteed that every branch is related explicitly to that specification without ambiguity. If the use of Git is adopted by 3GPP, then Gitlab would likely be the platform of choice. Gitlab provides the ability to create groups which can contain more groups and repositories. Therefore, the organization of repositories by working group (WG) or specification series would still be possible.
Each specification repository would contain every release and release version created for that specification. When creating a new generation, a pre-release version of the specification is created as version 0.1.0. The version number is incremented until the first stable pre-release version of the specification is completed as version 1.0.0. After its approval, with or without further changes, it would acquire the version number of the first release of the new generation, e.g., 21.0.0. The 'main' branch will be updated with latest version of latest official release made available. During the Release 21 timeframe, the specification would be updated through the approval, agreement, and merging of CRs into further versions, e.g., 21.1.0, 21.2.0, etc. Each tagged version represents a collection of CRs, which could come from multiple work items, which have been applied to the previous release. Each tagged version can be fast forward merged backed to 'main' branch. To create the next release, a branch would be initially created from the latest version of the current release, e.g., Release 21, v21.3.0. The new branch would be named, incrementing the current release number, i.e., Release 22. During drafting, the release branch could be prepended with the word draft until its first release, at which point a new branch with only the release number would be created. In the example of Figure 6.2.1.2.1-1, the initial version of Release 22 was based on Release 21, v21.3.0. Even after Release 22, v22.0.0 was created, progress continued on Release 21 with corrections, and a new version v21.4.0 was created in parallel. The 'main' branch will track the latest updates of the latest release, which in the example is Release 22, and no longer track Release 21 branch.
As the 'main' branch merges only the latest releases, there should not be any merge conflict during merge back into main. For this reason, merging using "fast-forward" option is recommended to be used. This allows Git to create the merge without creating a new commit. The main branch pointer simply moves to the same commit as the latest Release of the specification.
Figure 6.2.1.2.1-1: Simple repository structure with two releases
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.2 Branching
| As discussed in the previous section, each release would have its own branch, which when checked out would point to the latest version of that release. Creating a branch is the first step to making a modification to the specification. When creating a CR, the latest version of the affected release must first be checked out. Then, a branch would be created with a unique name from any other existing branch and the specification files would be edited and committed. Further modifications can be made inside the branch, for example when collaborating with others to correct a CR. Each distinct set of changes is committed. Every CR branch may remain independent from any other branch. If the CR is not agreed within a meeting cycle, but is continued in the following meeting cycle, use of Git will enable automated rebase of the CR to the new version of the specification (rebasing is described in clause 6.2.1.2.4).
See Figure 6.2.1.2.2-1 for an illustration of the structure. In this example, the release being worked on is Release 21, version 21.0.0. The initial version of the release was committed to the Release 21 branch, which was based on main. Then, three CRs were created as branches: CR1; CR2; and CR3. CR1 and CR3 were tentatively agreed during the meeting, but were updated in revisions CR1-r01, and CR3-r01 and CR3-r02, respectively. CR2 was rejected and no further changes were made.
Figure 6.2.1.2.2-1: CR Branching
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.3 Merging
| After the final revisions of CR1 and CR3 were ready they were marked as agreed, awaiting merging in plenary. During plenary, CR1 and CR3 were approved and merged into the Release 21 branch. Once all merging was complete, the latest commit (the last merge) was tagged with the next version, v21.1.0, for easy retrieval. See Figure 6.2.1.2.3-1.
Figure 6.2.1.2.3-1: Merging CRs into a new version
Some working groups merge CRs into what are called mega CRs, which contain many CRs as one to provide to plenary. These can be work item CRs or a collection of CRs that affect the same clauses in the specification. To create a mega CR, all the relevant agreed CRs during a meeting would be merged into a new CR with a cover page updated to apply to all of the component CRs. There is no difference between merging a set of CRs into the new release and merging a set of CRs into a new CR, but the branching diagram of Figure 6.2.1.2.3-2 is different because of the extra step of consolidating CRs into the v21.1.0_wi_cr integration (or draft) branch prior to merging into the new version of a release.
Figure 6.2.1.2.3-2: Merging with a mega CR
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.4 Merging Running CRs, Baseline CRs
| During the creation of a new release, the latest version of the active release is used as a baseline for a running CR (or baseline CR) to begin implementing the agreements made during the work item. The current procedure for baseline CR handling is described in Annex C.
The first running CR for 38.331 toward Release 19 for the AI/ML for physical layer WI was created from 38.331 v18.4.0. Since then, versions 18.5.0, 18.6.0, and 18.7.0 have been published. That means that between the initial version of the running CR and version 18.7.0, it had to be updated three more times and could go through an additional update yet. Each instance the official Release 18 specification is published with a new version, the updated version should be merged into the draft running CR of the new Release.
The process of merging is discussed in Section 6.2.1.2.3, but its purpose is different, wherein changes are applied to the current version of an active release to create the next version of the active release. Usually, when merging, the original version and the changes applied to the version are part of the same linear progression. That is, changes are merged into, e.g., v18.5.0, to create v18.6.0. When merging to upgrade the version of the running CR toward the new release, changes from two different versions of a similar document are being merged together, e.g., v18.5.0 is merged into a running v19.0.0. Therefore, conflicts of a different nature can arise: conflicts between CRs toward v18.5.0 fixing a bug and CRs toward v19.0.0 which did not assume the presence of said bug. After upgrading the version of the running CR, merge conflicts need to be carefully evaluated as not to undo the fixes provided by the current active release.
The example of Figure 6.2.1.2.4 below illustrates how merging to upgrade the version of the baseline specification of a running CR works. The initial version of the running CR was based on v18.4.0 of Release 18, in the branch called draft Release 19. Two commits were applied to the Release 19 branch since the time when it was branched from v18.4.0. At the same time, work on Release 18 continued, and v18.5.0 was created by merging the commits since v18.4.0 to the Release 18 branch and applying the v18.5.0 tag. To upgrade the version of the running CR, Git merge was used to apply the changes between v18.4.0 and v18.5.0 to the draft Release 19 running CR branch. The process can be repeated as Release 18 progresses.
Figure 6.2.1.2.4: Merging the latest specification into a running CR
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.5 Example of branching and merging during a release cycle
| Figure 6.2.1.2.5-1 is an example of how the mechanisms described in previous sections (branching, merging) can be applied during a release cycle. We take the example of Rel-22 work item phase and assume Rel-21 specifications are available in the Git repository. In this phase, Rel-21 specification maintenance will happen in parallel to normative work for Rel-22. The example is provided as an illustration only. We also indicate operations that are related to 3GPP meetings.
Figure 6.2.1.2.5-1: Example of branching and merging during a release cycle. The rebase operations indicated in this example (upgrade of the version of the specification that is used as base for the baseline CR) may be implemented by a Git merge operation.
The following figure, Figure 6.2.1.2.5-2 is an excerpt from the previous diagram, showing three CRs contributed toward the maintenance of Release 21. CR1 was simply noted, while CR2 and CR3 were agreed during the meeting after two and three revisions each, respectively. These CRs were merged into a draft Release 21 branch and further corrections were applied to improve the flow considering the addition of two CRs. Once the CRs were approved by plenary, they were merged into the published Release 21 branch and tagged as version 21.1.0.
Figure 6.2.1.2.5-2: Excerpt of maintenance from one meeting
Work item branches are used to aggregate the agreements for a work item in a CR that functions as a WI-specific draft to the next release of a specification, e.g., Release 22. Two WI branches: Work Item 1 and Work Item 2 were created from the published Release 21, version 21.0.0. Work Item 1 shows two meeting cycles worth of changes and Work Item 2 shows one meeting cycle worth of changes. After each meeting cycle, the changes applied to the current release, Release 21, are applied to the Work Item branches to keep them up to date. After the Work Items have progressed sufficiently, they are merged into a draft Release 22 branch which eventually becomes the published Release 22, version 22.0.0.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.6 Directory Contents
| The use of Git is agnostic to the format or formats of the files within, and can store any type of file, with the caveat that binary files are not well supported due to the difficulty in generating a difference between two versions of a binary file wherein a single change could affect multiple parts of the file. A single specification could have different ways of representing information and these different ways could be represented in different file formats such as Markdown, LaTeX, ASN.1, OpenAPI, MSC-Generator signalling, MSC-Generator block, Draw.io, and Mermaid. Additionally, file types that are less friendly to Git such as image files: portable network graphic (PNG) and scalable vector graphic (SVG), can be stored.
In one example, Markdown could be selected as the format for the main body of the specifications. 3GPP specifications contain many figures which need to be presented in a human-readable rendered form. Because Markdown lacks native support for direct insertion of figures, the files containing figures would need to be stored alongside the Markdown such that they could be inserted into the human-readable specification.
A git repository is essentially a directory similar to that which one can create on their computer. A sample directory structure could take the following form.
TS23.501 [Repository Name]
ts_23-501.md [Specification Body]
resources [Directory]
figure_4.1-1.svg [Image file]
figure_4.1-2.signalling [MSC-Generator diagram]
Editor’s note: Further study is needed on how to store and name image files corresponding to different versions and different releases of the same specification, and how to handle image files that were submitted with a CR and stored in the same repository but not eventually agreed.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.3 Description of procedures
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.3.1 Mapping Git procedures to Change Request processes
| We can compare the typical current CR procedure (Figure 6.2.1.3.1-1) to a potential future CR procedure with Git (Figure 6.2.1.3.1-2), relating each current step to the Git equivalent in the new procedure. The mapping provided is not meant to imply a solution, but rather to relate the Git flow to our current 3GPP flow. For instance, the second to last step in Figure 6.2.1.3.1-2 suggests that a TDoc representing the CR will be automatically generated and provided as a docx file which can be submitted. That is only one possibility.
For the purpose of 3GPP, additional fields can be added to the commit message, such as work item description (WID) or study item description (SID) code.
- Steps with solid green borders are nearly equivalent steps.
- Steps with a dashed orange border are modified from the original procedure.
- Steps with a squiggly black border are unique to each procedure.
Figure 6.2.1.3.1-1: Current typical CR procedure
Figure 6.2.1.3.1-2: One potential new CR procedure with Git
Editor’s Note: The feasibility of automatically generating a Word document with Track Changes from Git commits is for further study along with the required tool(s).
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.3.2 Creating a CR - workflow description
| This section describes the workflow for creating a CR. The table, Table 6.2.1.3.2-1, describes the steps required to create and upload a CR to the Git repository. Note that details related to TDoc reservation, and downloading an automatically generated TDoc will not be discussed in this section.
Table 6.2.1.3.2-1: Creating a CR – workflow description
#
Step
Git
1
Download the repository of the desired specification
git clone git@repository_address
2
Checkout the desired release branch, e.g., Release 19
git checkout release_19
3
Create a CR branch (will be based on the currently checked out branch)
git checkout -b release_19_cr
4
Edit and save the specification file(s) in an editor for the format
5
Add the file(s) for staging, i.e., to mark them as part of the commit
git add file.ext
6
Commit changes to the local repository, i.e., store the difference between the original version and the CR branch. The commit message describes the commit (the changes).
Editor’s Note: What information should be contained in the commit message is still under study.
git commit -m 'commit message'
7
Upload the changes to the remote repository, making them public.
git push release_19_cr
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.3.3 Updating a CR – workflow description
| After the first version of a CR has been pushed to the remote repository, it can be further modified by the original author or by other contributors. The CR branch can be worked on directly or one or more branches can be created to make changes. In this example, the focus will be on an author applying further changes to an existing CR. The procedure is described in Table 6.2.1.3.3-1.
Table 6.2.1.3.3-1: Updating a CR – workflow description
#
Step
Git
1
Checkout the CR branch
git checkout release_19_cr
2
Loop
2.1
Edit and save the specification file(s) in an editor for the format
2.2
Add the file(s) for staging, i.e., to mark them as part of the commit
git add file.ext
2.3
Commit changes to the local repository, i.e., store the difference between the original version and the CR branch. The commit message describes the commit (the changes).
Editor’s Note: What information should be contained in the commit message is still under study.
git commit -m 'commit message'
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.4 Intermediate form CR
| The time constraints and the large number of contributors to the revision of a CR could necessitate the use of an intermediate document format for use in collaboration. Today it is common for working groups to collaborate as follows.
1. Rapporteur uploads the initial version of a document, e.g., a CR.
2. A delegate downloads the latest version of the document.
3. The delegate renames the document by incrementing the version number and changing the company name.
4. The delegate edits the document by applying changes with track changes and/or by adding bubble comments.
5. The delegate uploads the document.
6. Process repeats until a deadline is reached or there are no further comments.
This procedure depends on delegates not commenting simultaneously on the document. In some groups, a lock file with the delegate’s email address is created and manually uploaded to indicate that no one else should edit the file. However, in Git, it isn’t obvious when someone is working on a file because files can be edited locally and Git does not have a mechanism by which a file can be locked for editing. Additionally, it is not easy to simultaneously view changes from many commits at the same time while viewing the author. This is particularly difficult when changes are applied to changes since each commit inherently implies an acceptance of all the earlier changes, including deletions and additions.
As a way to assist with collaboration, an intermediate docx format CR, autogenerated by scripts, could be used for collaboration purposes. When the discussion concludes, the changes applied with track changes would be accepted and ported back into the Git repository as a commit to the document. Because Git doesn’t have a concept of track changes and it always checks for all changes to a file, the entire affected clause could be copied directly into the file or an automated approach (if feasible) could be used. The process could be defined by replacing step 1 of the current procedure with the following.
1. Upon pushing a CR to the 3GPP repository, a docx CR is automatically generated containing an automatically filled CR cover page and two versions of the changes: the contents in their raw form (e.g., Markdown or LaTeX source) and the contents in a rendered form.
Then a new step is be introduced after the last step of the current procedure.
1. Manually or automatically copy the further updated text into the latest version of the file in Git.
2. Commit and push the changes to the 3GPP repository.
An example body of an intermediate form CR is shown in Figure 6.2.1.4-1.
Figure 6.2.1.4-1
Editor’s Note: This section describes a potential way to handle collaboration on CRs but a prototype is still being evaluated for feasibility. Git-native ways of collaboration are also under study and should not be excluded.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.2 Evaluation against requirements of section 4.3
| Editor's Note: Evaluation is FFS.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3 Proposal #3: Ways of Working on CRs during meetings when using Gitlab for preparation of CRs
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3.1 Description
| Gitlab on 3GPP Forge is used as a repository of identical copies of certain (parts of the) specifications that are written in text-based formats separately from the rest of the specifications written in Word. The primary normative reference of specifications remains stored on FTP.
Gitlab on 3GPP Forge is used for preparation and revision of CRs on text-based parts of specifications that are not written in Word (e.g. .yaml, .asn, .ttcn, .xsd, .json, .md, .adoc files). A CR has corresponding Git commits (as described in Figure 6.2.1.1.2-1: Example git branching and merging in draft TR21.802v0.1.2).
Drafting work occurs during and after meeting, for commenting in preparation for CR revision, including commenting by multiple delegates, i.e. collaboration on CRs (pain-point #12):
- This is the type of work done today over email discussions or during e-meetings or between WG meetings where companies provide comments on a draft update of a CR (today this uses FTP by updating a Word document with comments and revisions). It can be studied if Gitlab on the Forge can be used instead.
- This also includes the type of work done post-meeting in e.g. CT WGs using Gitlab on the Forge for checking the syntax and the correct implementation of agreed OpenAPI CRs.
Editor’s note: practicality/feasibility of using Gitlab on 3GPP Forge for collaboration on CRs need to be studied, assuming a large number of comments and revisions by a large number of delegates within a day.
At the start and at the end of the drafting work during and after the meeting, there shall always be a one-to-one correspondence between Git commits and a Tdoc number on 3GU for a CR with cover sheet in Word referencing at least the commits IDs. The correspondence shall be maintained between a revised CR with Tdoc number and the corresponding revised commits IDs.
The Ways of Working documented in this clause equally apply for draft CRs.
Gitlab on 3GPP Forge is used for drafting work on text-based parts of specifications that are not written in Word (e.g. .yaml, .asn, .ttcn, .xsd, .json, .md, .adoc files), in electronic meetings and in pre/post F2F meeting email discussions. Drafting work uses commits in Git that correspond to draft CRs, such as described in clause 6.2.1.1.2.
Drafting work can be one of two things:
- CR preparation
- If CR preparation is done using Gitlab on the Forge for (parts of the) specifications that may be written in text-based formats, a CR would be corresponding to Git commits (as described in Figure 6.2.1.1.2-1: Example git branching and merging in draft TR21.802v0.1.2).
- CR revision including commenting by multiple delegates, i.e. collaboration on CRs (pain-point #12)
- This is the type of work done today over email discussions or during e-meetings or between WG meetings where companies provide comments on a draft update of a CR (today this uses FTP by updating a Word document with comments and revisions). It can be studied if Gitlab on the Forge can be used instead.
- This also includes the type of work done post-meeting in e.g. CT WGs using Gitlab on the Forge for checking the syntax and the correct implementation of agreed OpenAPI CRs.
Editor’s note: practicality/feasibility of using Gitlab on 3GPP Forge for collaboration on CRs need to be studied, assuming a large number of comments and revisions by a large number of delegates within a day.
At the start and at the end of the drafting work, there shall always be a one-to-one correspondence between Git commits and a Tdoc number on 3GU for a CR with cover sheet in Word referencing the commits IDs and attaching the text-based file with the proposed changes to the zip file of the Tdoc. Intermediate versions/revisions of commits between the start and the end of the drafting work are considered as informal intermediate drafts. The same applies for a draft CR.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3.1.1 Description of tools
| The tools used in these Ways of Working are the following:
- 3GU for CR submission
- Word for CR cover sheet.
- Gitlab on 3GPP Forge for storage of text-based parts of specifications that are not written in Word, and at least for preparation of CRs or draft CRs
- Schema files for ensuring consistent use of styles for each specific text-based file format
- A tool within Gitlab for checking for syntax errors within code (in case of code)
- A tool within Gitlab for editing and generating a text-based file (with a specific format) from a Git branch with commits.
- A tool within Gitlab for generating a Word document with Track Changes corresponding to a commit (e.g. as available today for SA5 work on OpenAPIs on 3GPP Forge).
- Word for CR cover sheet. A text-based file as attachment to the CR cover sheet
- Gitlab on 3GPP Forge for drafting work
- A tool within Gitlab for checking for syntax errors within code (in case of code)
- A tool for editing and generating a text-based file (with a specific format) from a Git branch with commits, to be provided as attachment to a CR cover sheet
- Schema files for ensuring consistent use of styles for each specific text-based file format
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3.1.2 Description of procedures
| The following Ways of Working (WoW) are studied for collaborative work on drafting CRs.
In this clause, changes to the CR cover sheet data fields must be controlled through access to Gitlab, in order to maintain a one-to-one correspondence between commits and a CR referencing these commits.
It is also assumed that either reliable internet access (including Wi-Fi and backhaul) or reliable local Gitlab mirror (e.g. in 10.10.10.10) is available during the meeting.
The following Ways of Working (WoW) are studied when using Gitlab for collaborative work on drafting CRs.
In this clause, where Word is proposed to be used for the CR cover sheet, there is no expectation that editing this Word file directly will be necessary. Changes to the CR cover sheet data fields can be controlled through access to Gitlab or other tools. In this case, it could be sufficient to use a read-only file (e.g. PDF) for the CR cover sheet document.
Editor's note: The process by which CR cover sheet data is updated as part of the WoW is FFS.
Table 6.3.1.2-1: Ways of Working on CRs during meetings, when using Gitlab for collaborative work on drafting CRs.
Classification of Ways of Working
Way of Working on CRs during meetings
WoW#1
Gitlab is used for CR preparation and revision, and for drafting work in preparation for CR revision drafting work only outside WG F2F meeting weeks. Word is used only for the CR cover sheet. CR revision not possible during F2F meetings.
Word is not assumed to be used except for the CR cover sheet. CR submission on 3GU, where CR cover sheet references Git commits, and the attached text-file (e.g. .yaml) shows no change marks.
Any CR revision can only be done within Gitlab in preparation for a future meeting. Gitlab is not used by delegates during F2F meetings.
WoW#2
Gitlab is used only for CR preparation and revision, and for drafting work in preparation for CR revision,drafting work, outside and during WG F2F meeting weeks. Word is used only for the CR cover sheet. CR revisions via commits in Gitlab only done offline (not in real-time).
Word is not assumed to be used except for the CR cover sheet. CR submission on 3GU, where CR cover sheet references Git commits, and the attached text-file (e.g. .yaml) shows no change marks.
Session Chair may make real-time changes to a CR by copying some part of a text-based file in session’ notes written in Word, and making revisions using Track Changes for those changes to be taken as basis for further drafting work within Gitlab during the meeting. A revised CR with updated cover sheet is later provided with new Tdoc number for agreement during the meeting.
WoW#3
Gitlab is used for CR preparation and revision, and for drafting work in preparation for CR revision and for drafting work and formal work during WG F2F meeting weeks. Word is used only for the CR cover sheet. CR revisions via commits in Gitlab in real-time and offline (not in real time).
Word is not assumed to be used except for the CR cover sheet. CR submission on 3GU, where CR cover sheet references Git commits, and the attached text-file (e.g. .yaml) shows no change marks.
Real-time changes to CRs can be handled within Gitlab by a session Chair, or revisions can be left to “offline” drafting work by delegates. No use of Word for making revisions to a CR. For record keeping, CR needs to be agreed with Tdoc number and CR cover sheet.
Editor’s note: feasibility of displaying Gitlab on an overhead screen in a large meeting room is uncertain, especially for visualizing changes made in real-time to a CR.
WoW#4
Gitlab is used for CR preparation and revision. Word is used for CR presentation and for drafting work in preparation for CR revision during/after WG meetings. CR revisions via commits in Gitlab only done offline by the CR proponent/moderator.
Word is used for the CR cover sheet. CR submission on 3GU, where CR cover sheet references Git commits. A docx version showing Track Changes to the text-based file is attached to the zip file of the Tdoc for presentation of textual changes. An attached text-file (e.g. .yaml) showing the proposed update without change marks could optionally be attached to the zip file of the Tdoc.
During the meeting the Word format allows for changes by different authors and color highlights of changes to facilitate a discussion involving multiple parties and a quick presentation of updates (e.g. on the projector, by the chair).
Gitlab is used to store CRs that are to be submitted and also agreed CRs that are to be sent for approval to TSG plenary and subsequently to be implemented.
The following procedures are summarized:
- Offline/local drafting, editing and sharing of CRs
- Using Git with commit IDs with a one-to-one correspondence to a CR submitted on 3GU.
- Reservation and submission of CRs to 3GPP
- Using 3GU. Word is used for the CR cover sheet, referencing the corresponding commit IDs. A text-based file is attached, showing the proposed revision without revision marks.
- Displaying, revising and commenting on draft CRs during meetings for WoW#1, WoW#2 and WoW#3
- Displaying and commenting:
- Session Chair displays the proposed CR, which is a text-based file without Track Changes showing only the proposed revised version. This assumes that delegates have reviewed the Git commits prior to the session. Delegates provide verbal comments on the proposed CR.
- Gitlab is not displayed on a shared screen with overhead projection in a large meeting room, no editing in Gitlab by the session Chair.
- Session chair may copy-paste text in the session’s notes and make real-time revisions using Word Track Changes. The revisions serve as basis for another round of drafting work on Gitlab.
- If feasible, real-time changes to CRs can be handled within Gitlab by a session Chair with projection on an overhead screen in the meeting room.
- Revising and commenting: using Gitlab for another round of drafting and editing of the CR
- Displaying, revising and commenting on draft CRs during meetings for WoW#4,
- Displaying and commenting:
- Session Chair displays the proposed CR, which is showing changes to the text-based specification format with Track Changes and possible colour highlights and authors of changes identified. This avoids that delegates need to review the Git commits prior to the session. Delegates provide verbal comments on the proposed CR (note that the comments may be also provided as written comments via FTP version of the proposed CR, e.g. in e-meetings).
- Gitlab is not displayed on a shared screen with overhead projection in a large meeting room, no editing in Gitlab by the session Chair.
- Session chair may copy-paste text in the session’s notes and make real-time revisions using Word Track Changes.
- Revising and commenting: the CR uses the Word format only for discussion and presentation during a meeting. It is possible that different authors suggest revisions, as done for instance in the e-meeting procedures of SA2. Only the proponent/moderator of the CR is required to ensure a one-to-one correspondence between a revised CR submitted with Tdoc number and commits IDs in Gitlab.
- Detecting potential conflicts between CRs and resolving them
- Using Gitlab, during drafting or post-meeting after CRs are agreed. Resolving conflict requires bringing back the conflicting CRs to WG for revision, unless a non-technical fix can be found by MCC.
- Merging content from multiple CRs to a single CR
- Not necessary: each CR with a corresponding branch in Git can be merged into the main branch without requiring merging multiple CRs to a single CR.
- Approving and rejecting CRs in online sessions
- Via Tdoc number reserved and submitted on 3GU.
- Documenting approved, rejected, and revised CRs in meeting reports
- Via Tdoc number reserved and submitted on 3GU.
- Automatically implementing approved CRs to the desired specifications
- For CRs on text-based parts of specifications, automatic implementation by merging branches corresponding to approved CRs into the main branch of the desired specification in Gitlab.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3.2 Evaluation against requirements of section 4.3
| Editor's note: The evaluation is FFS
6.4 Proposal #4 OneM2M workflow
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1 Description
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.1 Description of tools
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2 Description of procedures
| |
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.1 Introduction
| Below is described a candidate workflow for using the 3GPP's GitLab environment (i.e. the 3GPP Forge) for handling CRs, TSs and TRs. This workflow is similar to the workflow used by the OneM2M (https://www.onem2m.org/) for handling of CRs, TSs and TRs with adaptations to the current 3GPP ways of working.
It should be noted that this workflow is only intended for CRs, TSs, TRs. Discussion papers handling would remain the same as today.
A potential variant of the OneM2M workflow is also presented in section 6.4.1.2.8. In that variant principles from the Gitflow model [5] have been adopted. The Gitflow model is 15 years old, well proven and widely adopted Git branching model.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.2 Overview
| Below is a diagram showing the workflow used for CRs in OneM2M. You might need to zoom in to see the details, but the diagram is also available in a higher resolution version here: https://forge.etsi.org/rep/cti/md-specs-dev/contribution-procedure/-/blob/master/simplified-process.md.
More details are also found here: https://forge.etsi.org/rep/cti/md-specs-dev/contribution-procedure/-/blob/master/contribution-process.md.
Figure 6.4.1.2.2-1
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.3 Git repository settings
| In this model each TS or TR has its own associated repository in the 3GPP Forge with a protected "main" branch (containing the latest version of the specification) with the following characteristics:
- The main branch is protected:
- Only MCC can merge into main branch
- Only TSG and WG officials can approve Merge Requests for the main branch
- This is the branch which comprises the latest version of the specification.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.4 Workflow for a WG meeting
| The following would happen for a WG meeting:
- Following the WG's pre-meeting schedule, delegates request for Tdoc numbers.
- With the Tdoc numbers allocated for the CRs, delegates should create "CR" branches which have in the name of the branch a reference to the tdoc number, e.g., CR/WG-YYMCXI_CR_Name. The CR branches are created from the main branch.
- At the tdoc submission deadline, delegates should create for each CR branch a Merge Request to merge the CR branch into main. The description of the Merge Request contains information as today's CR cover pages, i.e. a reason for change, summary of changes, consequence of not approved, etc. see more details in sub-clause 6.4.1.2.9.
- Optionally, in addition to the Merge Request, the working group could agree on that delegates should create and submit a docx-representation of the Merge Request. This is how OneM2M were operating during a transition phase, and the OneM2M Forge is automatically generating such docx-representations, a script that 3GPP could copy.
- During WG meeting, the submitted Merge Requests are reviewed, discussed among the delegates, if needed commented on in the Gitlab environment, updated and the agreeable Merge Requests are eventually agreed by the WG and tagged as agreed by the WG officials.
In Git, managing parallel changes is business as usual. For example, if a CR that needs to be edited by several delegates/companies during the WG meeting, the delegate responsible for that CR should create a branch from main/develop branch as described above. Other delegates following this CR will comment and propose improvements to the CR. We expect that, like today, in many cases such comments/proposals can be discussed directly face-to-face. However, sometimes detailed changes are also sometimes given in digital format. The 3GPP Forge has an excellent commenting functionality where one can give detailed comments on Merge Request which is very user friendly (more user friendly than the current ways of working where comment-bubbles are added to different docx-versions of the CR on the 3GPP FTP server).
In some cases, a delegate might however want to provide a more elaborate proposal, or make bigger changes to a proposed CR. The commenting delegate could in this case create a new branch from original CR-branch. If that proposed update is agreeable to those discussing the CR, that new branch can be merged into the original CR-branch after which the CR editor submits the updated Merge Request for agreement in the WG-meeting.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.5 Workflow for a TSG meeting
| During the TSG meeting, the CRs agreed in the preceding WG meetings have to be approved by the TSG. In GitLabs terms this means that the Merge Requests tagged as agreed during the WG meetings have to be now approved and merged in the main branch. This could be done following the steps below:
- In the TSG meeting, the Merge Requests tagged as "agreed" during the preceding WG meetings are reviewed (often in block), approved by the TSG officials and marked to be merged into main.
- MCC should also create a Merge Request aiming at updating the metadata of the specification such as version number, date, etc. Once this Merge Request is approved and merged the MCC should tag the corresponding merge commit with the version number and eventually add a version note to the tag description.
- Adding a tag to the main branch could also trigger pipelines to automatically publish the current version. See section below on how to publish a specification.
For the TSG-level CRs the workflow is similar with the WG CR workflow, namely during the TSG meeting the Merge Requests are discussed, reviewed, commented, updated and eventually approved to be merged into main.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.6 Maintenance for frozen specification releases
| To handle corrections CRs for frozen releases the current model proposes the following workflow:
- At the freeze of each release MCC creates a protected branch for the release to be frozen:
- release-xx-main branch created from the main branch
For the correction CRs to a frozen release, the protected branch will act or follow the same workflow as the main branch do for the ongoing release.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.7 Publishing the specifications
| Currently OneM2Ms approach is that they have an automated portal where all their specifications are found: https://specifications.onem2m.org/
Whenever a new version of their specification is ready, i.e. after CR implementation has completed, the latest specification is published and can be accessed on the portal. The portal allows the reader to browse all specifications and look at specific versions of each specification. The portal shows the specification in HTLM-format directly in the browser, but also allows the reader to download the specification in PDF- or Docx-format. A screenshot below shows an example:
Figure 6.4.1.2.7-1
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.8 Potential variant of the OneM2M workflow: GitFlow-like workflow
| One variant of the OneM2M workflow described above is the GitFlow work flow. In the GitFlow workflow a develop branch is used as an intermediate step when implementing Merge Requests onto the main branch based on these principles as follows:
- Protected main branch:
- Only MCC can merge into main branch
- Only TSG officials can approve Merge Requests for the main branch
- This is the branch which comprises the latest version of the specification.
- Protected develop branch:
- MCC and Delegates can merge into develop branch
- TSG and WG officials can approve Merge Requests for develop branch.
- This branch comprises the CRs agreed/ongoing CRs since the last version of the specification.
At the following TSG meeting, if all Merge Requests that were agreed in the WGs (and merged to their corresponding develop branch) are approvable, then the develop branch can be merged to the main branch (in a single commit). To merge the develop branch into the main branch, MCC should create a Merge Request which has the source branch develop or a spin branch of develop (version branch) and the target branch main. However, if some Merge Request which was agreed and merged by the WG is is not approvable at the TSG, that Merge Request need to be removed from the develop branch (the commit corresponding to that Merge Request needs to be reverted by the MCC). And after that the develop branch can be merged to main.
The benefit of this is that if all agreed Merge Requests are approvable, it requires only one commit to main per quarter. However, if some agreed Merge Requetsts are not approvable, some extra work would be needed.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.4.1.2.9 Handling CR cover page information
| In this model, the CR cover page information is converted from tabular format to JSON format as presented in the example below. Note that approach could be in both the OneM2M workflow or the alternative (GitFlow-like workflow described in clause 6.4.1.2.8).
CR-Form-v12.3
CHANGE REQUEST
<Spec#>
CR
<CR#>
rev
<Rev#>
Current version:
<Version#>
For HELP on using this form: comprehensive instructions can be found at
http://www.3gpp.org/Change-Requests.
Proposed change affects:
UICC apps
ME
Radio Access Network
Core Network
Title:
<Title>
Source to WG:
<Source_if_WG>
Source to TSG:
<Source_if_TSG>
Work item code:
<Related_WIs>
Date:
<Res_date>
Category:
<Cat>
Release:
<Release>
Use one of the following categories:
F (correction)
A (mirror corresponding to a change in an earlier release)
B (addition of feature),
C (functional modification of feature)
D (editorial modification)
Detailed explanations of the above categories can
be found in 3GPP TR 21.900.
Use one of the following releases:
Rel-8 (Release 8)
Rel-9 (Release 9)
Rel-10 (Release 10)
Rel-11 (Release 11)
…
Rel-17 (Release 17)
Rel-18 (Release 18)
Rel-19 (Release 19)
Rel-20 (Release 20)
Reason for change:
Summary of change:
Consequences if not approved:
Clauses affected:
Y
N
Other specs
Other core specifications
TS/TR ... CR ...
affected:
Test specifications
TS/TR ... CR ...
(show related CRs)
O&M Specifications
TS/TR ... CR ...
Other comments:
This CR's revision history:
{
"Specification": "Spec#",
"CR": "CR#",
"rev": "Rev#",
"Current version": "Version#",
"Proposed change affects": ["UICC apps", "ME", "Radio Access Network","Core Network"],
"Title": "Title",
"Source to WG": ["Source_if_WG"],
"Source to TSG": ["Source_if_TSG"],
"Work item code": ["Related_WIs"],
"Category": "Cat",
"Reason for change": "",
"Summary of change":"",
"Consequences if not approved": "",
"Clauses affected": ["", ""],
"Other specs affected": {
"Other core specifications": ["TS/TR", "CR"],
"Test specifications": ["TS/TR", "CR"],
"O&M Specifications": ["TS/TR", "CR"]
},
"Other comments": "",
"This CR's revision history": ""
}
This JSON formatted text containing the CR coverage page information could be added:
- In the commit message for the commits to the develop branch
- In the Merge Request Description field in GitLab
- As an entry in a change log file in the specification repository
From the options above, adding the JSON of the CR cover page in the commit message has the following advantages compared to the other two options:
- The CR information is included in the git history and “travels” along with the repository or the branch,
- The CR information is stored natively in the Git history which makes it independent of the platform used to store the repository, e.g., GitLab, GitHub, etc.,
- The CR information is displayed next to the CR changes in the git commit and can be visualized with any tool that displays the git history.
Figure 6.4.1.2.9-1
6.X Proposal #X
6.X.1 Description
6.X.1.1 Description of tools
6.X.1.2 Description of procedures
6.X.2 Evaluation against requirements of section 4.3
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 7 Overall evaluation
| Editor's note: Overall evaluation of combined proposals from sections 5 and 6, including trials.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 8 Recommendations
| Editor's note: Final recommendations
Annex A:
3GPP Stakeholder Survey on CR Tools
As part of the effort to develop tools ''New Working Methods'' during the years 2015-2022, a 3GPP stakeholder survey was performed in 2022 [3]. The goal of this survey was to provide clear input on requirements and expectations with respect to specification development with CRs. A summary of results of the survey are presented here.
NOTE: For those interested, the reference [3] includes also the data set used for the assessment summarized in the present document. There were also many interesting comments provided by responders to the survey which are omitted in this synopsis.
The interpretation of the survey is merely intended to be well-founded input to the present document.
The terms 'must have' or 'low priority' were used in the analysis of the survey. These terms are informative only.
A.1 Methodology
3GPP stakeholders were surveyed, with input specifically solicited from delegates, implementers, secretaries, OP delegates, 3GPP leaders (working group and TSG chairs, vice chairs).
Table A.1-1: Survey Response
Category
Responses
% of total
Delegate
556
91.3
Rapporteur of Specification Editor
144
23.7
Leader (Chair, Vice Chair)
17
2.8
Secretary or MCC
7
1.2
OP transposer
2
0.3
Moderator / Feature Leads
58
9.5
Engineer (who implements specifications in products or services)
39
6.4
Other (please specify)
17
2.8
The categories were not exclusive. A single responder could check both 'Delegate' and 'Rapporteur' for example. The categories were useful to select for specific evaluation for analysis and comparison.
All questions were of the form "I need…" and could be answered with results shown below. Only results that were not 'non-applicable' were counted.
0 [non-applicable];
1 [Not useful, don't do this];
2 [I don't need this, others might];
3 [Useful, would be helpful];
4 [I need this from time to time];
5 [I need this very often, a 'must have']
In order to assess the results for each question, the following was used to categorize the results:
Table A.1-2: Survey Response Interpretation
Interpretation
Positive Responses (3, 4 or 5)
Must have % rating "5"
µ and σ
Must Have
> 0.82
> 45% responses
µ + σ > 5.25
High Priority
0.75 > x > 0.82
40 – 45% responses
µ + σ > 4.8
Medium Priority
Low priority
< 65%
< 30% responses
µ - σ < 2
Strong indication of low priority
< 55%
< 20% responses
µ + σ < 1.5
The range of experience of responders varied, less than 3 years (newcomers) 20.5%, 3-6 years (since 5G) 24.8%, 7-14 years (since 4G) 29.6%, >14 years (since 3G) 25.1%
A.2 Major Findings
In the tables below, the needs are listed in their relative levels of needs. The survey question numbers (in the # column) remain so these items can be references in the rest of the TR. Please refer to the survey report [3].
Table A.2-1: Must have needs
#
Topic
Need
3.1
General
I need to review, edit and otherwise access CRs off-line, that is, with no access to the Internet.
3.5
General
I rely on 'recovery features' so that I do not lose work if there is an interruption or failure of some kind (computer, software, network, etc.) while editing or creating CRs.
3.6
General
I rely on tools to indicate incorrect spelling in documents I edit or compose.
3.8
General
I use 'advanced search' capabilities for search and replace (match case, find whole words, use wildcards, search 'up' vs. 'down', etc.)
3.9
General
I rely on 'what you see is what you get' presentation of content on pages as I edit or create content in CRs.
3.14
General
I need to be able to use the tool to open multiple windows (or to split windows) to different parts of the same document.
3.16
General
I need the tool to capture every change made in a CR such that the change identifies who made the change and when it was made (similar to Microsoft Word Revision Marks).
3.14
General
I need to be able to use the tool to open multiple windows (or to split windows) to different parts of the same document.
3.18
General
I need the tool to capture every change made in a CR such that the change identifies who made the change and when it was made (similar to Microsoft Word Revision Marks).
3.19
General
I need to be able to add comments to any content in a CR including text, figures, header fields, etc. These comments need to capture my name and the time they were made.
3.20
General
I need to be able to delete comments from CRs.
3.21
General
I need to be able to respond to comments so that the response is kept in the context of the comment.
3.22
General
I need to be able to see comments and responses to comments, so that I see who provided the comment and when.
3.24
General
I need the tool to enable me to reject any change. [NOTE 1]
8.1
Tables
I need to adjust the column and row widths, as the automatic width and height settings are insufficient.
8.5
Tables
I merge cells.
8.6
Tables
I split cells.
8.7
Tables
I adjust cell alignment (e.g. upper left, centered, lower right, etc.).
10.1
Text
I need to identify the appropriate clause number when inserting a new clause into a specification under change control.
10.2
Text
I highlight text.
10.3
Text
I enter or modify subscripts and superscripts in text.
10.4
Text
I insert symbols (non-alphanumeric characters).
10.9
Text
I create and modify multi-level bulleted lists in CRs.
13.1
Equations
I need to have a 'what you see is what you get' style of equation editor, such as the Open Math ML editor.
17.3
Code
I need code to be displayed in a form optimized for readability of the given language, e.g. appropriate indentations, colors, etc.)
17.6
Code
I need the tool to identify every character that is proposed to be changed by a CR (similar to word revision marks) rather than just identifying entire lines that are proposed to be changed.
23.1
CR check
I need to check the CR specification information (is the specification number correct, the latest version used for the corresponding release, the CR number correct (assigned to this CR) and that the work item code (WIC) exists in the release corresponding to this CR (or allowed for a mirror CR).
23.4
CR check
I need to check whether the source, reason for change, summary of change and consequences if not approved sections are filled in. I need to identify multiple sources and authors in the source field.
23.5
CR check
I need to check whether the category is filled in and is an allowed value.
23.6
CR check
I need to check whether the CR header is 'clean' (no revision marks or comments) since these are not allowed in the revision of CRs that can be agreed in WG or approved in TSG.
23.7
CR check
I need to check whether the sections affected field is filled in and that this corresponds exactly to the sections included in the set of changes that the CR contains.
23.8
CR check
I need to check whether the 'Other specs affected' tick boxes are checked, and if they are, that they correspond to existing specifications.
23.9
CR check
I need to check that the CR revision number is correct.
23.11
CR check
I need to check that a CR is based on the most recent version of the specification, for the specification and release targeted by the CR.
27.1
CR impl.
I need to be able to identify a set of CRs and a source specification to which the changes will be applied. As a result I need to produce two versions of the target specification - one 'clean' and the other 'revision marked.'
NOTE 1: 'Accepting changes' to the source specification in a CR is not allowed since a CR must show all changes to the unmodified specification text. The only way to accept changes in a CR is for TSG to approve the CR and the change to be implemented to create a new version of a specification.
Table A.2-2: High priority needs
#
Topic
Need
3.13
General
My company / organization needs to create, modify and otherwise develop CRs (and specifications) autonomously, so that the data is only stored and accessible by my company / organization.
3.23
General
I need to be able to search for comments from specific authors (see all comments by a particular commenter).
5.1
Figures
I adjust the formatting of images (png, jpg, etc.) in CRs (e.g. size, centering).
5.3
Figures
I create editable figures within the tool (using figure drawing mechanisms to drop elements, resize, type text, etc.)
5.4
Figures
I create (and edit) editable figures externally from the tool and import or paste them in.
8.4
Tables
I adjust the indentation of cells (above, below, left, right) surrounding the text content of the cells.
8.8
Tables
I adjust text direction (e.g. to write vertically instead of horizontally).
8.9
Tables
I shade rows or columns (e.g. with light gray).
8.10
Tables
I need to add equations to cells in tables.
8.12
Tables
I need to add figures to cells in tables.
10.5
Text
I insert non-printing characters (e.g. non-breaking spaces) in text.
10.6
Text
I remove all formatting of text.
10.7
Text
I view non-printing characters (including non-breaking spaces, carriage return, tabs, etc.)
13.3
Equations
I need the tool to capture every change made in an equation such that the change identifies who made the change and when it was made. [NOTE 1]
17.1
Code
I need code to be embedded within the same document as the rest of the Technical Specification to which the code is associated. Note: this question asks how important it is, in your opinion, that code is embedded in the specification itself rather than provided some other way, e.g. by reference or as a component in the CR or specification 'zip file', etc.
20.1
MSC
I need MSC to be embedded within the same document as the rest of the Technical Specification to which the code is associated. [NOTE 2]
20.2
MSC
I need the machine-readable format of MSCs to be stored in a CR or specification such that it can be modified by others.
23.2
CR check
I need to check that the CR title does not change after it is assigned.
23.3
CR check
I need to check whether the date is in the proper format.
25.1
CR check
I need to check CRs for compliance to TR 21.801 drafting rules, e.g. use of styles, non-breaking spaces, avoiding use of tabs, avoiding 'hanging paragraphs,' etc.
25.2
CR check
I need to check that CRs use the latest CR Form (template).
25.4
CR check
I need to identify all abbreviations in a CR that are neither defined in the specification, nor in TR 21.905, nor in the cited 3GPP specifications in the reference section.
25.7
CR check
I need to check whether a set of CRs clash with each other where the CRs target the same version of the same release of a specification. Note: A CR clash is when more than one CR proposes changes to the same text.
25.8
CR check
I need to check if a CR includes all changes compared with the previous specification version and against a previous rev of the same CR. Note: This could happen if a change were made without 'track changes' being activated. This question also asks whether it is difficult to identify 'new' changes if all changes are marked the same way.
27.2
CR impl.
I need to check if there are clashes between the set of CRs applied to the same source specification. If this is the case I need to create a list of all the clashes to resolve in order to create a new version of the specification correctly.
27.3
CR impl.
I need to determine if there are any 'warnings' or 'errors' present in all the input CRs. If so, I need to list all these warnings and errors. The errors must all be corrected in order to create a new version of the specification correctly.
NOTE 1: This requirement would go beyond Revision Marks in Microsoft Word that merely show that an equation has changed and not what in a figure has changed.
NOTE 2: This question asks how important it is, in your opinion, that code is embedded in the specification itself as it is (as MSC) as opposed to using an external tool to generate a figure (e.g. PNG file) and including that in the specification.
Table A.2-3: Medium priority (missing some 'high priority' criteria)
#
Topic
Need
3.4
General
I need a tool that allows importing of documents and content created in Microsoft Word. [NOTE 1]
3.10
General
I need a way to compare two user-specified versions of the same specification, (e.g. TS 38.331 v17.2.0 vs v17.0.0) to identify the differences. I also need to be able to filter this 'difference' presentation, so that I can select a specific Work Item Code, (e.g. only show changes due to NR_MBS-Core). [NOTE 1]
3.12
General
I rely on keyboard shortcuts for efficiency (beyond cut/copy/paste/undo). [NOTE 2]
3.17
General
I need for the tool to enforce the marking of any change in a CR compared to the latest version of the targeted release of the source specification. [NOTE 2][NOTE 3]
5.5
Figures
I create and import non-editable images (png, jpg, etc.) instead of editable figures when I cannot create the figure I require.
5.6
Figures
I need images that are not editable in the tool to be stored as an editable source file in the CR or specification so that the image can be modified by others.
5.7
Figures
I need the tool to capture every change made in a figure such that the change identifies who made the change and when it was made.
8.2
Tables
I need to apply formatting to tables beyond those provided in 21.801 styles, and beyond basic text formatting (e.g. bold). Examples of 'going beyond 21.801' are shading of rows.
8.11
Figures
I need to add figures to cells in tables.
10.8
Text
I adjust paragraph attributes that are not in the 3GPP template (e.g. alignment, indentation, spacing before and after lines). [NOTE 2]
13.2
Equations
I need to have a mark-up language based editor for equations, such as latex.
17.2
Code
If embedded within the same document as the rest of the technical specification, I need the tool to provide automatic extraction of the code portions in the technical specification. [NOTE 2]
17.4
Code
I need the tool used for creating and editing code to perform syntax checking. [NOTE 2]
17.5
Code
I need the tool used for creating and editing code to perform compilation checking of the code. [NOTE 2]
17.7
Code
I need the tool to identify conflicts (i.e. that would result in syntax or compilation errors) with code in other CRs and the specification that the CR targets. [NOTE 2]
23.10
CR check
I need to warn me if there are no 'change affects' tick boxes ticked as this is a 'warning': though in some special cases this is intended, lack of tick boxes ticked is generally an error. [NOTE 2]
23.12
CR check
I need the tool to help create mirror CRs, especially so that the header page is set up properly. [NOTE 2]
25.3
CR check
I need to check references: does each reference added have text in the specification that refers to it? Do all references added to specification text have corresponding references? [NOTE 2]
25.6
CR check
I need to search change marked documents for all changes by a specific source 'individual member' (associated with the marked revision). [NOTE 2]
27.4
CR impl.
I need to be able to use the CR and specification tool to apply pseudo-CRs as changes to a source specification. [NOTE 4]
27.5
CR impl.
I need to create a next version of the target specification with as much assistance from automated implementation as possible. [NOTE 5]
27.6
CR impl.
I need to create an interim version of the target specification that reflects the specification status after the first of more than one working group meeting in a single quarter. [NOTE 6]
NOTE 1: Though many were positive about this, there was a high σ, resulting in a strong trailing edge. Skepticism?
NOTE 2: There was a large variation in responses.
NOTE 3: This is not true today. Change marking is manually controlled by the user. It is thus possible to improperly create an incorrect CR with changes that are not marked.
NOTE 4: pseudo-CRs are currently informally structured documents. Please take into account in answering this question that in order to support implementation of pseudo-CRs in a tool, it may be necessary that pseudo-CRs documents become more formal in their structure. For example, it may be necessary to define and fill in a pseudo-CR header page.
NOTE 5: This was a 'must have' when rapporteurs and secretariats are selected as the responding group. In general responses, only 72% responded positively. The criteria for unambiguous 'high priority' is 75% or higher response of 3, 4 or 5.
NOTE 6: Though interim versions of specifications have no official status since CRs are only sent to TSG for approval at the end of a quarter, some delegates may benefit from the ability to view the cumulative result of all agreed CRs (and even postponed CRs) to a given specification.
In all rows of Table A.2-3, there was less than 40% 'must have' responses.
Table A.2-4: Low and very low priority
#
Topic
Need
3.2
General
I need a tool which does not require any additional software to be installed on my PC beyond those tools used today.
3.3
General
I use in-company or other non-3GPP tools which require access to the CR database and/or the full set of CR files.
3.7
General
I use different layouts of CRs while I work on them, including print layout and 'web' layout (without pages or fixed width).
3.11
General
I rely on help facilities.
3.15
General
I need to collect all source files together with the CR, for example, the source file used to create a figure, equation, etc. Note that even though it is not required today in all 3GPP groups to collect all source files for figures, equations, etc. with the CR, in future this could become a requirement.
5.2
Figures
I embellish the presentation of images in CRs (e.g. adding a border, drop shadow, other 'effects.')
25.5
CR check
I need to search change marked documents for all changes after a given date, e.g. after CEST yesterday.
A.3 Specific Requirements for Rapporteurs and Secretaries
In a follow up study, Q25 and Q27 were reviewed specifically in the responses of secretaries and rapporteurs.
Q25: Do you have any other needs with respect to filling in or checking the header sheets of CRs?
Q27: Do you have any other needs with respect to checking the correctness of CRs?
Table A.3-1: Must Have for Rapporteurs and Secretaries
#
Topic
Need
25.1
CR check
I need to check CRs for compliance to TR 21.801 drafting rules, e.g. use of styles, non-breaking spaces, avoiding use of tabs, avoiding 'hanging paragraphs,' etc.
25.2
CR check
I need to check that CRs use the latest CR Form (template).
25.3
CR check
I need to check references: does each reference added have text in the specification that refers to it? Do all references added to specification text have corresponding references?
25.7
CR check
I need to check whether a set of CRs clash with each other where the CRs target the same version of the same release of a specification. Note: A CR clash is when more than one CR proposes changes to the same text.
25.8
CR check
I need to check if a CR includes all changes compared with the previous specification version and against a previous rev of the same CR. [NOTE 1]
27.1
CR impl.
I need to be able to identify a set of CRs and a source specification to which the changes will be applied. As a result I need to produce two versions of the target specification - one 'clean' and the other 'revision marked.'
27.2
CR check
I need to check if there are clashes between the set of CRs applied to the same source specification. If this is the case, I need to create a list of all the clashes to resolve in order to create a new version of the specification correctly.
27.3
CR check
I need to determine if there are any 'warnings' or 'errors' present in all the input CRs. If so, I need to list all these warnings and errors. The errors must all be corrected in order to create a new version of the specification correctly.
27.5
CR impl.
I need to create a next version of the target specification with as much assistance from automated implementation as possible.
NOTE 1: This could happen if a change were made without 'track changes' being activated. This question also asks whether it is difficult to identify 'new' changes if all changes are marked the same way.
Interestingly, secretaries agreed that the following is very important, but some rapporteurs disagreed:
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 25.4 I need to identify all abbreviations in a CR that are neither defined in the specification, nor in 21.905, nor in the cited 3GPP specifications in the reference section.
| Some secretaries found this useful, but most found the feature unimportant:
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 25.5 I need to search change marked documents for all changes after a given date, e.g. after CEST yesterday.
| While most rapporteurs agreed this was important, there was disagreement with secretaries. One even commented: "don't do this!"
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 27.6 I need to create an interim version of the target specification that reflects the specification status after the first of more than one working group meeting in a single quarter.
| NOTE 1: Though interim versions of specifications have no official status since CRs are only sent to TSG for approval at the end of a quarter, some delegates may benefit from the ability to view the cumulative result of all agreed CRs (and even postponed CRs) to a given specification
While some rapporteurs found this important, there is disagreement. Secretaries do not see this as important.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 27.4 I need to be able to use the CR and specification tool to apply pseudo-CRs as changes to a source specification.
| NOTE 2: Pseudo-CRs (pCRs) are currently informally structured documents. Please take into account in answering this question that in order support implementation of pseudo-CRs in a tool, it may be necessary that pseudo-CRs documents become more formal in their structure. For example, it may be necessary to define and fill in a pseudo-CR header page.
This topic could have been underdeveloped in the survey. It seems very strange that one would automate CR quality improvement and implementation, but not support pCRs. During the early phase of development of specifications, pCRs are used to incorporate most of the content that will remain forever, before change control begins.
Annex B:
Survey of specification formats, tools, and CR processes in use by 3GPP WGs in 2025
In 2025, 3GPP WGs are using Word for writing specifications and for working on CRs/pCRs in meetings. Additional tools (e.g. Visio, Msc-generator, PlantUML) are used for crafting objects that are then embedded in Word. For some WGs, such as RAN1 and RAN2, specifications are published only using Word with embedded objects. In order to address specific needs of certain WGs, some WGs use additional file formats for writing annexes or attachments to the specifications (e.g. YAML file/codec codes).
Table B-1 below summarizes the various tools in use as of 2025 in 3GPP WGs. When only Word is mentioned, it is implied that built-in tools for handling equations, tables, and for drawing figures are also commonly being used. The table indicates when parts of the specifications are also stored on 3GPP Forge (https://forge.3gpp.org), while when not indicated the storage of the specifications is only on 3gpp.org/ftp/Specs also accessible via the 3GPP portal 3GU (https://portal.3gpp.org/).
Table B-1 – Survey of formats and tools in use as of 2025 by 3GPP WGs for specifications and CRs
Specification formats/tools
Formats/tools/processes used for CRs
CT1
Word (Visio and MSC-GEN for figures). XML files are included as annex in the Word file of a TS. OpenAPI files are included as .yaml files (Notepad++) in the ZIP file of a TS, and the OpenAPI text is also copied into the Word doc of that TS in annexes. A YAML file is also stored as a fixed branch in Git on 3GPP Forge. These 3 versions must be identical.
3GPP Forge for OpenAPI YAML files: OpenAPI descriptions are extracted from the annex of the 3GPP Technical Specifications and made available as stand-alone YAML files, identified by a file name composed of the API name prefixed by the TS number of the specification containing the OpenAPI description. All these files are then stored in a common repository managed by Gitlab on the 3GPP Forge for testing.
YAML text parser (Notepad++) to generate YAML file (note that new swagger version does not support saving of YAML file and cross checking).
OpenAPI YAML syntax checker (Swagger tool)
XML syntax checker/validator.
CDDL and JSON syntax checker/validator.
Word + Visio, Excel
regex101: used to build, test, and debug regex, to check regular expressions online.
CRs are submitted in 3GU, stored on 3gpp.org/ftp, and after the meeting agreed CRs are tested using Git in 3GPP forge:
1. A company submits a CR for an OpenAPI using Word in 3GU, showing track changes to the YAML text copied from the Word annex of a TS with OpenAPI. The company submitting the CR shall check and correct errors early, and list the impacted API(s) on the cover page. The list can be generated using 3GPP Forge.
2. CT1 discusses CRs for that OpenAPI during the meeting. The CRs agreed during the CT1 meeting don’t include a separate .yaml file but just a Word file.
3. After the CT1 meeting, the TS rapporteur merges all agreed CRs for that OpenAPI into a .yaml file (using NotePad++), as part of drafting the TS update.
4. The TS rapporteur checks for syntax errors in Swagger, and provides the checked .yaml file to 3GPP Forge and on FTP draft folder (and also use Github e.g. to detect issues with APIs referring to each other). If CR implementation errors are found the TS Rapporteur proposes a correction and asks Source companies if they agree and asks for a revision to next meeting/plenary.
5. Delegates review the comments from rapporteur, .yaml files and draft TS for correctness and provide feedback on the email reflector.
6. For CRs which are agreed by CT1 and need a correction, the source companies provide a company revision to next plenary with an indication corrected due to errors found during pre-implementation and checking.
7. Once the CRs (including Word docs and .yaml files) are approved in plenary, TS rapporteur provide final version of TS and .yaml files. MCC is doing a final check (e.g. running their Macros) and TS is uploaded to ftp/Specs and the Git branch is fixed and cannot be updated anymore by delegates/rapporteurs. MCC is creating a new draft branch for next plenary for testing.
Similar is valid for correcting or changing a specification’s text, with the difference that Git is not used for text other than .yaml files.
CT3
See CT1
See CT1
CT4
See CT1
See CT1
CT6
Word (Visio for figures)
Word + Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN1
Word, Excel (in some cases for TRs)
Excel (included as attachment in a single zip file for some TRs). The formula tool built in Excel is used for calculating e.g. link budgets.
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
In RAN1 (and some other RAN WGs such as RAN2), TS rapporteurs are tasked at certain stages with providing a CR for their responsible TS which merges together all or many of the changes agreed during a RAN1 meeting relating to a given release, and these editor’s CRs are reviewed by delegates before submission to RAN plenary. TS rapporteurs are not tasked with providing a draft TS merging all approved CRs for their TS. This is done by the MCC officer (RAN1 secretary) after RAN plenary for all TSs under RAN1 responsibility. Draft TSs are provided for review by delegates after which the new version of the TSs is published.
RAN2
Word (Visio and MSC-GEN for figures)
ASN.1 syntax checker (not included in spec)
Word (Visio and MSC-GEN for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN3
Word (Visio and MSC-GEN for figures)
ASN.1 syntax checker (not included in spec)
Word (Visio and MSC-GEN for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN4
Word (Visio for figures), Excel (in some cases)
At least one TR (37.941) includes multiple Excel spreadsheets in separate files in the same zip file
Word (Visio for figures), Excel
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN4 use separate tool for the CA/DC band combinations requests (Excel so far; database under construction)
RAN5
Word, Excel, Visio
Excel and Visio (included as attachment in a single zip file, and implemented as part of TR 38.903/38.905). The formula tool built-in Excel is used for calculating e.g. uncertainty values.
Machine processable files specified in TTCN-3 language (.ttcn) are provided as attachments in the zip file of a TS, and are not embedded in the Word doc of a TS. Several TTCN-3 compilers are used for syntax checking the TTCN-3 files.
Word, Excel, Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA1
Word
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA2
Word, Visio
Word, Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA3
Word
Machine deliverable parts (.asn, .xsd) are provided as attachments in the zip file of a TS, and are not embedded in the Word doc of a TS.
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA3-LI SWG:
- Word + Visio
- 3GPP Forge for ASN.1, following these instructions: https://forge.3gpp.org/rep/sa3/li/-/wikis/How-To/Create-a-CR
A summary of the process used with 3GPP Forge by SA3-LI is provided below:
Changes to 3GPP specifications still have to go through the 3GPP change control procedure, even if the changes are held on the Forge. A CR can refer to the Forge for any changes to the machine deliverable parts, rather than writing them out in a change-marked Word document.
SA3LI puts each CR and each plenary meeting in its own branch. A CR entered as a branch in 3GPP Forge requires to first obtain a CR number from the 3GPP Portal, and to finally be submitted to a WG meeting with a proper CR form. A CR branch follows the branching convention and a name of the form cr/{deliverable/{CR number}, and it is placed in the branch for the plenary meeting that might eventually approve the CR. Revisions of a CR are possible during a WG meeting, and the corresponding commits must be updated along with increasing the CR revision.
One CR branch can include one or more commits, each with a commit hash, which is a unique and durable identifier of the changes in the Forge. This hash (or the URL associated with the commit hash) is to be copied in the "Comments" section of the CR, along with the merge request number.
- 3GPP Forge for storing Visio diagrams and their revisions, following these instructions:
https://forge.3gpp.org/rep/sa3/li_diagrams
Visio diagrams are embedded in the specification Word file. 3GPP Forge is used only as a repository for Visio diagrams that can be downloaded for editing. There is no preview for this type of file within 3GPP Forge. A naming convention is defined allowing for referencing each Visio diagram to its specification and specification release and version.
SA4
Word (Visio, PowerPoint and draw.io for figures, and Msc-generator for UML sequence diagrams). Word macros are used to extract a candidate list of abbreviations from the text, and to support formatting of the TR/TS deliverable.
3GPP Forge for stage 3 OpenAPI YAML and XML Schema Definitions. For some deliverables, the copy on 3GPP Forge is normative; for others it is only an informative copy and the normative API definition is specified in an annex to the TS.
Reference implementations of codecs are developed collaboratively in a WG-specific project area on 3GPP Forge, but the normative version is made available as an attachment to the published TS.
Audio test sequences are published on the 3GPP FTP server.
Video conformance bitstreams and reference sequences are stored externally to 3GPP.
c.f. further details as described for CT1.
Word (Visio, PowerPoint and draw.io for figures, and Msc-generator for UML sequence diagrams).
CRs are submitted in 3GU, stored on 3gpp.org/ftp.
Stage 3 OpenAPI YAML changes are prototyped in a WG-specific project area on 3GPP Forge and manually committed to the 5G_APIs repository following TSG approval.
SA5
Word (PlantUML for figures)
3GPP Forge for stage 3 OpenAPI - c.f. further details as described for CT1
Word (PlantUML for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
3GPP Forge for stage 3 OpenAPI, XSD, and YANG data models. SA5 YANG data models and APIs are validated by an automated pipeline that runs for every push or merge-request event. This pipeline is composed of two stages, validation and generation. Generation stage runs an automated Word CR text generation for the corresponding merge-request.
The generated Word CR text is a changed marked word document that includes all changes made by the associated merge-request. Each modified file (YANG model, OpenAPI or XSD) will be included as a change in the Word CR text. This can be included in the Word Change Request document. The Word CR text can be downloaded from the merge-request webpage or the pipeline-page as described above for the detailed log output files.
SA6
Word
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
In addition, MCC provides a number of file templates that are to be used by delegates when drafting CRs, specifications and other document types that are prepared in Word format. These templates are regularly updated and available in meeting-specific folders such as https://www.3gpp.org/ftp/tsg_ran/TSG_RAN/TSGR_108/Templates. Some templates are also available at https://www.3gpp.org/ftp/Information/All_Templates.
MCC also provides a number of tools (Macros) to help with using 3GPP Styles, available at the same link as above. "Unofficial" macros are also used by some groups for specific purposes e.g. ASN.1 review in RAN2
For specific purposes, such as for the collection of evaluation results in an excel worksheet, other templates may be provided by the rapporteur in the course of a study or work item.
Annex C:
CR procedure in use by 3GPP WGs in 2025 for specifications in docx format
C.1 Common aspects of the CR procedure
According to TR 21.900, “Once a specification has been approved by the TSG and version x.0.0 (where x >= 3, corresponding to the Release - see table 4 of TR 21.900) has been produced, it shall be considered to be under change control. Any technical change which may be identified for inclusion in the specification from this point on shall be accomplished by means of a Change Request (CR).”
C.2 Initial submission and iteration of a p/CR
A p/CR proposes modifications to a Technical Specification (TS) or an external Technical Report (TR). The following process outlines typical p/CR handling: steps a) and b) cover initial submission, steps c) and d) cover treatment of p/CRs at the beginning of the meeting, steps from e) to g) detail the iteration phase during the meeting, and steps from h) to m) describe the finalization phase. The iteration phase is described generically, encompassing both at-meeting and post-meeting activities.
a) The p/CR author reserves a TDoc number for a new p/CR in the 3GU Portal and proceeds as follows.
1) Select in the portal the document type and fill in the meta-data: impacted specification, work item(s), Release number, and the CR category. If the document type is either pCR or draft CR, no CR number or revision number will be provided. Otherwise, a CR number and revision number will be provided by the portal.
2) Download the pre-filled CR template or the pCR template. Note the following guidance from TR 21.900: “It is strongly recommended that the author make use of this facility rather than filling in a blank CR cover from the stock template.”
3) Download the target version of the Technical Specification (TS) or Technical Report (TR) and propose modifications.
- Option 1: Edit the specification directly with track changes enabled and copy the modified clauses.
- Option 2: Copy clauses into the p/CR and edit them with track changes enabled.
4) Fill in any missing fields and isolated impact analysis and/or reason for change (if required) in the p/CR cover page.
5) Fill in the numbers of impacted clauses in the CR cover page.
6) Compress the document to ZIP format and rename the file only to contain the TDoc name.
7) Upload the p/CR via the 3GU portal.
b) Optionally or depending on the procedures of the WG, the specification rapporteur and the secretary review the p/CR prior to the meeting and proceed as described below. Note the following guidance from TR 21.900 regarding the role of the specification rapporteur: “Review all CRs to the specification prior to agreement in the Working Group. This includes identifying and resolving clashes”.
1) Download the TDoc list from the 3GU portal.
2) Download the CR, e.g., via the 3GU portal or FTP server.
3) Decompress the document to docx format.
4) Verify the correctness of the CR meta data on the CR cover page, ensure that the CR is prepared in accordance with specification drafting rules, and based on the target version of the TS or TR.
5) Inform the CR author and the meeting chairman or session chairman, e.g. via email, about any issues in the cover page or in the content of the CR.
c) The meeting chairman or session chairman takes notes of the received comments, e.g. via email, to decide actions regarding the CR treatment during the meeting.
d) If the p/CR reaches consensus during the meeting, the pCR will be implemented in the specification, the CR will be submitted to TSG subject for approval, and the process continues in step i). If the p/CR is not pursued, the process terminates. If the p/CR is deferred to offline discussion, the chairman assigns a company to gather feedback and come back with the outcome of the discussion where the scope of the offline discussion may encompass a single p/CR or multiple p/CRs. The p/CR author is tasked to author the p/CR revision, use a TDoc number allocated by the secretary, either prior to or after the offline discussion, and come back with p/CR revision(s).
e) The p/CR author makes a draft revision available to the group, e.g. via the FTP server, over email or other means according to the group’s practices, which can result in variations or duplicates of the same revision being modified independently. In larger working groups, the iteration may require sharing of documents, e.g., via FTP server- In that case, the collection of feedback can be carried out, for example as follows:
1) If FTP server is used, upload a draft revised p/CR or a discussion document to a folder as a starting point for the offline discussion.
2) May inform the working group about proposed changes to the p/CR e.g. via email reflector and request other companies to provide feedback or, given that FTP server is used, to upload further draft revisions of the p/CR or comments on the p/CR before the offline discussion deadline is passed. Interested companies may also directly monitor changes to the p/CR or the discussion document on the FTP server, and upload further draft revisions or comments, e.g., with tracked changes, without need for exchange of email.
f) In Interested companies may provide feedback on the p/CR, for example, in the following manner.
1) Infer the latest version of the revised p/CR or the discussion document, for example, from the working group naming convention, download the latest version from the folder and store it as a local copy.
2) Change the filename of the downloaded file in alignment with the working group naming convention (e.g. including company name, version number, etc.), propose modifications, and upload the modified local copy to the FTP server’s folder.
3) If a collision happens with other delegates concurrently modifying and uploading the same version, reiterate from step f1), i.e., re-edit all modifications from scratch in the latest version. Continue the reiteration until uploading is possible without collisions.
4) In some groups, feedback may also be provided over email, e.g. for specific wording suggestions
g) In case the draft version shall be uploaded as a new TDoc, the p/CR author submits the latest draft version as a TDoc subject for the whole working group discussion and decision including the following steps (if FTP server is used):
1) Download the latest version from the FTP server.
2) Request for a TDoc number unless already allocated prior to the offline discussion.
3) Update the p/CR cover page including updated revision history, rename the file to the TDoc number and compress to zip format.
4) Upload the TDoc, e.g., to Inbox folder of FTP server or 3GU portal, with the new TDoc number as zip file name.
h) The p/CR author presents the revision, and the process continues as described in step d).
i) The specification rapporteur implements the approved pCRs.
j) The secretary prepares CR packs for TSG submission This step does not apply to pCRs.
1) Allocate TSG CR pack numbers.
2) Download WG TDoc list and manually add a CR pack number to the agreed CR.
3) Upload the modified TDoc list to 3GU portal for automatic generation of CR packs.
4) Download the CR packs from 3GPP FTP server and submit them via 3GU portal for TSG approval.
k) The secretary implements approved CRs.
1) Download the TSG TDoc list and approved CR packs.
2) Download the latest versions of the specifications.
l) The specification rapporteur reviews the draft CR implementation.
1) Download the draft specification from 3GPP FTP server. Verify the correctness of the CR implementation against the approved CR.
2) If there are errors, the secretary creates a new draft until the implementation is correct.
m) The specification is published via 3GU portal, and the CR database is updated.
C.3 Specific aspects of the CR procedures
Editor’s note: Other WGs will be considered during the study and have been considered as part of the common procedures in clause C.1 and C.2.
C.3.1 Cross-WG aspects
DraftCR used by a Working Group (WG A) for changes to a specification under responsibility of WG B: The draftCR does not get a CR number in WG A. Revision history on the cover page of the draftCR can’t be filled in due to absence of revision number. After a draftCR has been endorsed by WG A, it is transferred to the WG B for agreement. The WG B turns the draftCR into a CR and allocates a CR number. If WG B agrees the CR, it is further transferred to TSG for approval.
C.3.2 RAN3 aspects
RAN3 handles CRs for corrections and technical enhancements and improvements (TEI) as described in clause C.2.
For handling of baseline CRs there are several differences. These differences are described here also including excerpts from RAN3’s internal TR 30.531 which provides the detailed procedure e.g. rules for use of tracked changes.
- TR 30.531 clause 5.3.2 bullet 10: “For complex issues which cannot be solved in one meeting, it is encouraged to use Baseline CRs. A Baseline CR is used as a container CR, incorporating individual agreeable proposals of CRs. ”
Initial submission: Some cover sheet information (reason for change, summary of change, consequences if not approved, clauses impacted, linked specifications) may be missing from the baseline CR upon initial submission. This information is often added when baseline CR content becomes stable towards the completion of the work item, by the baseline CR editor or during the final CR review. TR 30.531 provides the following instructions for baseline CR submission to the meeting:
- At the beginning of each meeting, the editor of a baseline CR must resubmit the last endorsed version of the baseline CR. Any editorial changes from the editor of the baseline CR must be marked by a different username for track changes than the username used for the changes from the agreed text proposals.
- It is the baseline CR editor's responsibility to make sure at all times that there are no changes on changes in the baseline CR.
- It is encouraged to use a CR number also for the Baseline CR and update the revision number with each new revision. This way it is clear which version of the baseline CR is being discussed. In the end of the meeting the Baseline CR is marked as "Endorsed" in the meeting minutes.
At-meeting iteration: The submitted baseline CR is re-endorsed at the start of the meeting. Input for at-meeting iteration of the baseline CRs is provided in Text Proposals (TPs) submitted to the meeting. One or more TP moderators are nominated to merge input from different companies into TP(s) that will be agreed during the meeting week. TR 30.531 provides the following instructions for TP preparation and submission:
- When requesting a TDoc to propose changes/updates to a baseline CR, one should use the Tdoc type "other” and indicate in the abstract the TDoc of the baseline CR that the changes are targeting.
- Text proposals for changes/updates to the baseline CR must keep the track changes from the latest endorsed version of baseline CR (i.e. DO NOT accept the changes already existing in the baseline CR) and must use a different user name, in MS Word's Track Change Options, for the new proposed changes (different user name than the one used in the baseline CR track changes). Also, Do NOT use CR cover page in text proposal to the baseline CR documents.
Aggregation of CRs into a running p/CR or mega p/CR – Post-meeting treatment of a p/CR: The baseline CR editor will implement agreed TPs during post-meeting email review. TR 30.531 provides the following instructions for this step:
- If the proposal from the TDoc type "other", is agreeable, the TDoc will be merged in the Baseline CR with a TDoc Status: "agreed".
- After each meeting, the baseline CR editor must provide, as soon as possible in the RAN3 email reflector, a draft implementation of all agreed proposals. When implementing an agreed text proposal, the baseline CR editor must set the username in MS Word's Track Change Options equal to TDoc number of the document from which the changes are coming. The baseline CR editor must maintain, in "This CR's revision history" field of the cover page, the list of Tdoc numbers of the agreed and implemented text proposals.
- At the deadline of the email review, the editor of a baseline CR has to provide the final version of the baseline CR using the TDoc number allocated by MCC. In this version, only one single username must be used in the Track Change Options for all the changes from the different agreed text proposals.
C.3.3 SA2 aspects
SA2 agrees many CRs and pCRs at each meeting. Before the meeting, TDOC numbers are assigned to CRs and pCRs using the 3GPP portal; for CRs, CR numbers are also assigned in that manner.
For physical SA2 meeting, only the author can provide revisions of CR and pCRs, but other companies typically suggest multiple updates in email discussions or during offline drafting sessions, making use of changemarks, different authors, and text highlights to distinguish the changes. It is also a frequent praxis that not all input documents are opened during an SA2 meeting due to time constraints, but the authors of similar CRs or pCRs work together to merge their contents, again making use of different authors and colour coding to show the different origins of changes.
For e-meetings, between official CR or pCR versions (with separate TDOC numbers) any company can provide revisions and any of those versions can be agreed and made a new official CR version. There are conventions for numbering those CR revisions in a way that allows any company to provide them without MCC support and number clashes (TDOC number and CR revision number remain unchanged, but “revn” is appended to TDOC numbers, where “n “is the next free number). Those revisions typically are based on the last previous revision, and change marks, different authors, and text highlights are used to highlight the new changes.
There are typically several revisions of a CR or pCRs before agreement. CR or pCR revisions (with new TDOC numbers) during the meeting are assigned by SA2(vice) chairs, possibly without immediate MCC support, and may not be immediately visible in 3GPP databases and 3GPP tooling. The presentation of CR revisions is expected to be brief and focus on changes compared to previous versions; the chairs display those revisions on the screen and colour coding of new changes is important to aid this process.
If two SA2 meetings occur between an SA plenary, no new versions of 3GPP specs will be made available by MCC after the first meeting. Thus, there is a frequent need to update CRs agreed at the 1st SA2 meeting during the 2nd SA2 meeting, e.g. due to textual overlaps. In such cases, any company can request a new revision of an agreed CR, and new changes that discussions should focus upon are expected to be highlighted (although also changes from the 1st SA2 meeting are still shown with change marks).
Time for delegates to review CR versions, and time in the end of SA2 meeting week to fix minor mistakes is very limited. Normally CRs are pre-agreed, the author is tasked to produce a “clean” version (no changes-on-changes or colour highlights), possibly also with some extra updates captured by the chair, and the final CR version is not presented. However, there is a possibility for delegates to check pre-agreed CRs before the close of the SA2 meeting and the final so called “block-approval” and to request CRs to be revised to fix mistakes.
Annex D:
Overview of GitLab and 3GPP Forge
D.1 Description
GitLab is a web-based DevOps lifecycle platform that provides a complete set of tools for software development, collaboration, and project management. It is widely used by teams to plan, build, test, deploy, and monitor software applications. Here’s a breakdown of the key features and purpose of GitLab:
- Version Control
- Built on Git, GitLab allows developers to track changes, collaborate on code, and manage branches and merges efficiently.
- Continuous Integration/Continuous Deployment (CI/CD)
- GitLab CI/CD automates the process of building, testing, and deploying code, enabling faster and more reliable software releases.
- Issue Tracking & Project Management
- Teams can create, assign, and track issues, milestones, and epics. It supports Agile and Scrum workflows with boards, lists, and burndown charts.
- Code Review & Collaboration
- Developers can review code through merge requests, discuss changes, and approve or reject contributions before merging.
- Security & Compliance
- GitLab includes built-in security scanning (SAST, DAST, dependency scanning) and compliance tools to identify vulnerabilities early in the development process.
- Container Registry
- GitLab provides a built-in container registry for storing and managing Docker images.
- Wiki & Documentation
- Teams can create and maintain project documentation directly within GitLab.
- Self-Hosted or Cloud-Based
- GitLab is available as a SaaS (cloud) solution or can be self-hosted on your own infrastructure.
Why Use GitLab?
- All-in-One Platform: Combines version control, CI/CD, issue tracking, and more in a single interface.
- Open Source: GitLab Community Edition is free and open source, with enterprise options available.
- Scalability: Suitable for small teams, large enterprises, and open-source projects.
- Integration: Works with popular tools like Jira, Slack, Kubernetes, and more.
GitLab vs. GitHub vs. Bitbucket
- GitLab: Focuses on the entire DevOps lifecycle, with strong CI/CD and self-hosting options.
- GitHub: Popular for open-source projects and developer communities, with a focus on code hosting and collaboration.
- Bitbucket: Often used by teams already in the Atlassian ecosystem (e.g., Jira).
The 3GPP Forge is a 3GPP self-hosted GitLab platform in which git repositories can be organized in projects belonging to members groups or subgroups.
D.1.1 Members, Groups and Projects
Forge members can be organized into groups and subgroups. A member can be part of multiple groups and subgroups. In each group or subgroup, a member can have one of the roles listed below. Roles define the actions a member is authorized to perform on the groups’/subgroup’s projects/git repositories.
- Guest: The Guest role is for users who need visibility into a project or group but should not have the ability to make changes, such as external stakeholders.
- Planner: The Planner role is suitable for team members who need to manage projects and track work items but do not need to contribute code, such as project managers and scrum masters.
- Reporter: The Reporter role is suitable for team members who need to stay informed about a project or group but do not actively contribute code.
- Developer: The Developer role gives users access to contribute code while restricting sensitive administrative actions.
- Maintainer: The Maintainer role is primarily used for managing code reviews, approvals, and administrative settings for projects. This role can also manage project memberships.
- Owner: The Owner role is typically assigned to the individual or team responsible for managing and maintaining the group or creating the project. This role has the highest level of administrative control and can manage all aspects of the group or project, including managing other Owners.
D.1.2 Making changes to the files of a git repository/project
Different versions of a git repository files can coexist on different branches of that git repository. Making changes to a version of the files is done by committing the changes also known as adding a commit to a branch. Changes to the files from a branch/version can be applied to another branch/version by merging the source branch into the target branch. To prevent unauthorized changes to a branch, Forge/GitLab introduced the concept of protected branches. For a git repository, it is possible to define as many protected branches as needed.
The following applies to a protected branch:
- To merge a given branch (source branch) into a protected branch (target branch) a member of the project has to create first a Merge Request.
- For a given project is possible to specify the lists of members who are authorized to Approve the Merge Requests and how many Approvals are required before the source branch of the Merge Request can be merged into the target branch of the Merge Request.
- For a project is possible to define which members roles are authorized to effectively merge the source branch of the merge request info the target branch of the Merge Request. The list of members who can approve can be different from the list of members who can merge.
D.1.3 Making a project publicly available
Making a Forge project publicly available, i.e., accessible even by the users who don’t have a Forge account, can easily be done via the repository mirroring feature. More specifically, on the same or on a different GitLab instance it is possible to create a public repository which mirrors/reflects an internal repository. The mirroring can be set up to be unidirectional, e.g., only the changes applied to the protected branches of the internal repository are mirrored on the branches of the public repository, while the changes applied to the protected branches of the public repository are not reflected back on the branches of the internal repository. Furthermore, for a higher security and to ensure that the internal repository is and remains the unique source of truth, the public repository can be set in such a way that no user, member of anonymous user, can make changes on the protected branches of the public repository.
Annex E:
Proposal mapping to 3GPP Styles
E.1: Expressability of all content types used in 3GPP
The following is a complete list of elements defined by 3GPP TR 21.801 [2], as well as the corresponding Markdown and LaTeX. This table is relevant to all alternative proposals in the present document. Proposals in which text is formatted using styles in DOCX or ODT fully support 3GPP drafting rules. This annex documents where other proposals do not support 3GPP drafting rules.
While it may be possible to force required formatting of 3GPP specifications based on the drafting rules through explicit introduction of HTML formatting, this possibility is not listed in the table as it extends beyond the use of Markdown or LaTeX as proposed in the current document.
Table E.1-1: 3GPP Content Expressability in proposed formats
Style Element
Purpose
Markdown (Proposal 3)
LaTeX (Proposal 5)
Comment
B1
Used for lists and for forcing indented text.
*
+
-
For intented text, it is possible to use blockquote '>'
FFS
B2
As above, indented 2x.
<spaces> * + or -
>>
FFS
B3
As above, indented 3x.
<spaces> * + or -
>>>
FFS
B4
As above, indented 4x.
<spaces> * + or -
>>>>
FFS
B5
As above, indented 5x.
<spaces> * + or -
>>>>>
FFS
EN
Editor's note content.
NO EQUIVALENT
FFS
EQ
equations are added as embedded content using the MS Equation Editor
FFS
EW
used for definition of symbols
NO EQUIVALENT
FFS
EX
Example content.
NO EQUIVALENT
FFS
FP
Free paragraph, left justified
text
FFS
This format is essentially the same as 'Normal' style except that it does not have a 9pt space below it.
Heading 1
Identifying sections
#
FFS
Heading 2
Ibid
##
FFS
Heading 3
Ibid
###
FFS
Heading 4
Ibid
####
FFS
Heading 5
Ibid
#####
FFS
Heading 6
Ibid
######
FFS
Heading 7
Used for section labels that are not included in the table of contents.
NO EQUIVALENT
FFS
Heading 8
Used for annexes of TRs
NO EQUIVALENT
FFS
There is no difference in format compared to Header 1
Heading 9
Used for annexes of TSs
NO EQUIVALENT
FFS
There is no difference in format compared to Header 1
NF
Notes to figures
FFS
NO
NOTE content
NO EQUIVALENT
FFS
Normal
Free text
text
FFS
NW
NOTE content formatted differently
NO EQUIVALENT
FFS
As per NOTE format, with no 9px spacing after the text. It is used to create dense lists of NOTEs)
PL
Programming language text
```
example: ``` asn1
-- asn1 text
```
FFS
TAC
For ordinary table cells, centered
table cell content, centered
FFS
TAH
For header cells
table header content
FFS
TAL
For table cells that are left justified
table cell content left justified
FFS
TAN
NOTE formatted content for tables.
NOTE: This content could in principle be the same as TAL - there is no formatting difference.
NO EQUIVALENT
FFS
TAR
For ordinary table cells, right justified
table cell content
FFS
TF
For table/figure labels below the table/figure
NO EQUIVALENT
FFS
TH
For table/figure labels above the table/figure
NO EQUIVALENT
FFS
TT
For the table of contents
NOTE: This content is automatically generated by MS Word
Proposal 3 identifies a means to automatically generate a table of contents.
FFS
superscript
include superscript text
^text^
FFS
subscript
include subscript text
~text~
FFS
non-breaking space
for inseparable strings, e.g. code names, spec names. "- use non-breaking spaces (°) or hyphens (—) in order to avoid unexpected wrap around between two words and/or numbers (e.g. 50°cm, 1°000, clause°6, annex°A, table°1, figure°1, TR°21°801—1, etc.). These characters appear as normal spaces ( ) or hyphens (-) when printed out;" [2]
FFS
non-breaking hyphen
Ibid
‑
FFS
symbols
Any non-alphanumeric character such as a greek letter
&<symbol name>; or
&#<unicode sequence>;
FFS
bold
This formatting is allowed.
**text**
FFS
italic
This formatting is alowed.
*text*
FFS
bold italic
This formatting is alllowed.
***text***
FFS
tab space
This character is used to align text following clause names, figure or table headers, special text regions such as editor's notes, notes, examples, bulllet lists, etc.
NO EQUIVALENT
FFS
hyperlinks
This formatting is allowed.
[text](link-text)
FFS
images
This formatting is allowed, and used in centered alignment.
Rendering of Markdown for the image will not be centered.
FFS
tables
Tables are essential content. Merging of rows and columns is used in some specifications.
| Header 1 | Header 2 |
|------------|-------------|
| Cell 1-1 | Cell 2-1 |
| Cell 1-2 | Cell 2-2 |
Or
+----------+----------+
| Header 1 | Header 2 |
+==========+==========+
| Cell 1-1 | Cell 2-1 |
+----------+----------+
| Merged Cell 1 |
+---------------------+
Each row must be in a single paragraph with no carriage return/line feeds. To add new lines, the HTML "<BR>" must be explicitly added. It is extremely difficult to read and diffcult to create tables in Markdown format if the rows extend over more than one line (80 characters).
\begin{table}[h]
\centering
\caption*{Table 4.2-1: Supported transmission numerologies.}
\begin{tabular}{|c|c|c|}
\hline
$\mu$ & $\Delta f =2^{\mu}\cdot 15$ [kHz] & Cyclic prefix \\
\hline
0 & 15 & Normal \\
1 & 30 & Normal \\
2 & 60 & Normal, Extended \\
3 & 120 & Normal \\
4 & 240 & Normal \\
5 & 480 & Normal \\
6 & 960 & Normal \\
\hline
\end{tabular}
\end{table}
highlighting
Though 3GPP TR 21.801 states "Other text decoration such as highlighting, blinking, shadow, embossed, etc shall not be used." highlighting is extensively used in drafting CRs to call out attention to text.
Embedded HTML is needed for this, e.g.:
<MARK> text </MARK>
FFS
reserved characters
The following characters are used in 3GPP specifications and currently (in MS Word) do not require any special handling. In some proposals characters need to be escaped.
Examples:
\ ` * _ { } ( ) # + - . ! < >
Some of these only need to be escaped in certain contexts (e.g. at the beginning of a line of text)
These characters are used in ordinary text in specifications.
\ backslash anywhere
` backtick anywhere
* asterix anywhere
_ underscore anywhere
{ } curly braces only for some variants of Markdown
[ ] square braces anywhere
( ) parentheses only if following [...]
# hash mark anywhere
+ plus sign only at the beginning of a line
- minus sign or hyphen only at the beginning of a line
. dot
! exclamation mark
< > less than, greater than anywhere
& Ampersand first character of continuous strings
These reserved characters can be interpreted incorrectly when rendering Markdown for output unless the characters are escaped, as Markdown control information or as embedded html. Though it is possible to follow these rules, it is not obvious when to do so and so training and careful checking of texts is essential.
FFS
NOTE: ASCIIDOC is not compared in the table above. It could be included in future if there is interest to do so.
Annex FE:
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-07
6GSM#01
6GSM-250008
Endorsed TR Skeleton
0.0.0
2025-08
6GSM#02
6GSM-250101
Inclusion of endorsed pCRs 6GSM-250041, 6GSM-250045, 6GSM-250046, 6GSM-250048, 6GSM-250050
0.0.1
2025-09
6GSM#02
6GSM-250131
Inclusion of endorsed pCRs 6GSM-250107, 6GSM-250108, 6GSM-250121, 6GSM-250125, 6GSM-250126,
6GSM-250127, 6GSM-250128, 6GSM-250129,
6GSM-250130
0.0.2
2025-09
SA#109
SP-251075
Further editorial cleanup and submission to TSG SA/CT/RAN joint session for review.
0.1.0
2025-09
SA#109
Additional editorial cleanup including cover page after SA#109
0.1.1
2025-10
6GSM#03
6GSM-250201
Inclusion of endorsed pCRs: 6GSM-250216, 6GSM-250218, 6GSM-250228, 6GSM-250230, 6GSM-250234, 6GSM-250236, 6GSM-250237, 6GSM-250238, 6GSM-250240, 6GSM-250241, 6GSM-250243
0.1.2
2025-11
6GSM#04
6GSM-250301
Inclusion of endorsed pCRs: 6GSM-250311, 6GSM-250313, 6GSM-250318, 6GSM-250322, 6GSM-250323, 6GSM-250324, 6GSM-250325, 6GSM-250327, 6GSM-250329, 6GSM-250333, 6GSM-250334, 6GSM-250330, 6GSM-250332
0.1.3
2025-12
SA#110
SP-251315
Further editorial cleanup and submission to TSG SA/CT/RAN joint session for review.
0.2.0
2025-12
SA#110
SP-251617
Presentation to TSG SA for information.
1.0.0
2026-02
6GSM#05
6GSM-260001
Inclusion of endorsed pCRs: 6GSM-260012, 6GSM-260021, 6GSM-260023, 6GSM-260027, 6GSM-260029, 6GSM-260033, 6GSM-260034, 6GSM-260035, 6GSM-260036, 6GSM-260037, 6GSM-260038, 6GSM-260041, 6GSM-260043
1.0.1
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.4 Rebasing Merging Running CRs, Baseline CRs
| Editor’s note: This section will be reconsidered and is left here for the purpose of describing the concept of porting changes from the current release into running CRs as to keep the CRs up to date. A different approach will be studied whereby changes from the current release would be merged into the running CRs instead of using rebase.
During the creation of a new release, the latest version of the active release is used as a baseline for a running CR (or baseline CR) to begin implementing the agreements made during the work item. The current procedure for baseline CR handling is described in Annex C.
The first running CR for 38.331 toward Release 19 for the AI/ML for physical layer WI was created from 38.331 v18.4.0. Since then, versions 18.5.0, 18.6.0, and 18.7.0 have been published. That means that between the initial version of the running CR and version 18.7.0, it had to be updated three more times and could go through an additional update yet. Each instance the official Release 18 specification is published with a new version, the updated version should be merged into the draft running CR of the new Release.Each update requires a manual transcription of the CR to the latest version of the specification.
The process of merging is discussed in Section 6.2.1.2.3, but its purpose is different, wherein changes are applied to the current version of an active release to create the next version of the active release. Usually, when merging, the original version and the changes applied to the version are part of the same linear progression. That is, changes are merged into, e.g., v18.5.0, to create v18.6.0. When merging to upgrade the version of the running CR toward the new release, changes from two different versions of a similar document are being merged together, e.g., v18.5.0 is merged into a running v19.0.0. Therefore, conflicts of a different nature can arise: conflicts between CRs toward v18.5.0 fixing a bug and CRs toward v19.0.0 which did not assume the presence of said bug. After upgrading the version of the running CR, merge conflicts need to be carefully evaluated as not to undo the fixes provided by the current active release.
Git can optimize the procedure of upgrading the version of a running CR to the latest version of the affected specification by use of a function called rebase. The function can be a little complicated, so the documentation is left here for reference (https://git-scm.com/docs/git-rebase).
Rebase mimics the effect of merging changes (commits) in a parent branch to an existing child branch but it does so by rewriting the commit history such that it appears as if the rebased branch was branched from the latest version of the specification. It can be explained through use of the previous example, where the parent branch is the Rel-18 branch and the child branch is a Rel-19 branch. Starting with v18.4.0, changes were applied based on agreements from the AI/ML for physical layer WI and contributed as a Rel-19 running CR. Between then and the next meeting, v18.5.0 was released and more agreements were made in the WI. Prior to implementing the new agreements, the Rel-19 CR, initially based on v18.4.0, would be rebased to v18.5.0 by applying all the changes applied to v18.4.0 to apply a v18.5.0 baseline to the Rel-19 running CR. Rebasing ports the changes to v18.4.0 and preserves the implementation of the agreements from the Release 19 WI. When rebasing, there could still be conflicts between the running CR and the changes to the current specification version. In this case, the running CR should be updated to adapt to the text of the current release to resolve the conflict and the current release should be left as-is.
The example of Figure 6.2.1.2.4 below illustrates how merging to upgrade the version of the baseline specification of a running CR works. The initial version of the running CR was based on v18.4.0 of Release 18, in the branch called draft Release 19. Two commits were applied to the Release 19 branch since the time when it was branched from v18.4.0. At the same time, work on Release 18 continued, and v18.5.0 was created by merging the commits since v18.4.0 to the Release 18 branch and applying the v18.5.0 tag. To upgrade the version of the running CR, Git merge was used to apply the changes between v18.4.0 and v18.5.0 to the draft Release 19 running CR branch. The process can be repeated as Release 18 progresses.
The example of Figure 6.2.1.2.4 below illustrates how rebasing works. The initial version of the running CR was based on v18.4.0 of Release 18, in the branch called Release 19. Three commits were applied to the Release 19 branch since the time when it was branched from v18.4.0. At the same time, work on Release 18 continued, and v18.5.0 was created by merging the commits since v18.4.0 to the Release 18 branch and applying the tag. To upgrade the version of the running CR, Git rebase was used to apply the v18.5.0 commits to the Release 19 running CR. The process can be repeated as Release 18 progresses.
Figure 6.2.1.2.4: Rebasing Merging the latest specification into a running CR
Editor’s note: It should be understood that the rebasing procedure is not intended to be used or to be necessary for use by most delegates.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.2.1.2.5 Example of branching, and merging and rebasing during a release cycle
| Figure 6.2.1.2.5-1 is an example of how the mechanisms described in previous sections (branching, merging, rebasing) can be applied during a release cycle. We take the example of Rel-22 work item phase and assume Rel-21 specifications are available in the Git repository. In this phase, Rel-21 specification maintenance will happen in parallel to normative work for Rel-22. The example is provided as an illustration only. We also indicate operations that are related to 3GPP meetings.
Figure 6.2.1.2.5-1: Example of branching and merging during a release cycle. The rebase operations indicated in this example (upgrade of the version of the specification that is used as base for the baseline CR) may be implemented by a Git merge operation.Example of branching, merging and rebasing during a release cycle
The following figure, Figure 6.2.1.2.5-2 is an excerpt from the previous diagram, showing three CRs contributed toward the maintenance of Release 21. CR1 was simply noted, while CR2 and CR3 were agreed during the meeting after two and three revisions each, respectively. These CRs were merged into a draft Release 21 branch and further corrections were applied to improve the flow considering the addition of two CRs. Once the CRs were approved by plenary, they were merged into the published Release 21 branch and tagged as version 21.1.0.
Figure 6.2.1.2.5-2: Excerpt of maintenance from one meeting
Work item branches are used to aggregate the agreements for a work item in a CR that functions as a WI-specific draft to the next release of a specification, e.g., Release 22. Two WI branches: Work Item 1 and Work Item 2 were created from the published Release 21, version 21.0.0. Work Item 1 shows two meeting cycles worth of changes and Work Item 2 shows one meeting cycle worth of changes. After each meeting cycle, the changes applied to the current release, Release 21, are applied to the Work Item branches to keep them up to date. After the Work Items have progressed sufficiently, they are merged into a draft Release 22 branch which eventually becomes the published Release 22, version 22.0.0. See clause 6.2.1.2.4 for details on rebasing.
|
5c416a273356c09854424ee0fcfb397b | 21.802 | 6.3 Proposal #3: Ways of Working on CRs during meetings when using Gitlab for collaborative draftingpreparation of CRs
| |
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 1 Scope
| The present document studies and assesses enhancements to the management aspects of management data, focusing on data discovery, data collection, data storage, data access etc., for 5G-Advanced. The study aims to identify the new functionalities, or enhancement to the data management capabilities and propose potential solutions.
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 28.622: "Telecommunication management; Generic Network Resource Model (NRM) Integration Reference Point (IRP); Information Service (IS)".
[3] 3GPP TS 28.319: "Access control for management services".
…
[x] <doctype> <#>[ ([up to and including]{yyyy[-mm]|V<a[.b[.c]]>}[onwards])]: "<Title>".
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 3 Definitions of terms, symbols and abbreviations
| |
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
<ABBREVIATION> <Expansion>
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 4 Use Cases
| 4.1 Request and Report of External Management Data
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 4.1.1 Use Case#1-1: Time Issue of External Management Data
| 4.1.1.1 Description
External management data are modelled in TS 28.622[X] by ExternalDataType IOC (clause 4.3.73). This IOC defines attributes to indicate the type of external management data and related meta data.
Specified meta data are
- mediaLocation: “address from which the described external management data can be retrieved. “
- externalDataTypeSchema: “URI where the MnS consumer can get the schema to parse the external management data.”
- externalDataScope: “concrete scope (e.g., geographical areas) which the external management data is applicable.”
4.1.1.2 Problem Statement
The attribute mediaLocation of IOC ExternalDataType specifies the endpoint where to retrieve the external management data. However, there is no indication on the validity of this data on a time scale. E.g. for which period of time applies the provided external data is applicable. Is this a record of the past, or a prediction for the future. The information of time is of importance in case of a request for historical data as well as for present data or for future data.
The explicit information of time regarding the requested or reported external management data is missing.
4.1.1.3 Potential Requirements
Editor’s Note: This clause is to describe potential requirements for the identified issue.
4.1.1.4 Potential Solution
Editor’s Note: This clause is to discuss possible solutions for the identified issue.
4.2 UE Data Collection
4.2.A Use Case#<A>: <Title>
4.2.A.1 Description
4.2.A.2 Problem Statement
4.1.A.3 Potential Requirements
4.1.A.4 Potential Solution
4.3 Enhancement of Management Services Access Control (MSAC)
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 4.3.1 Use Case#3-1: Access control for performance metrics
| 4.3.1.1 Description
When an MnS consumer requests the collection of performance metrics using the PerfMetricJob IOC (see clause 4.3.31 of TS 28.622 [2]), the MnS producer needs to be able to determine whether the MnS consumer is authorized to collect such data or not.
4.3.1.2 Problem Statement
Clause 7.3 of TS 28.319 [3] defines the AccessRule class associated to a given MnS consumer identified by their Identity and Role classes. The AccessRule class includes the following attributes as defined in clause 7.3.3 of TS 28.319 [3]):
Table 4.3.1.2-1: AccessRule properties
Attribute Name
S
ruleName
M
dataNodeSelector
M
operations
M
actions
O
componentCData
O
The componentCData attribute of the AccessRule class is defined as an optional attribute which specifies notification types and performance metric names.
From the definition of the componentCData attribute of the AccessRule class, it’s not clear how the MnS producer can use this attribute to determine the performance metrics that an MnS consumer is allowed to collect on a set of managed object(s) (represented by the dataNodeSelector attribute of the AccessRule class).
4.1.1.3 Potential Requirements
PREQ-FS_ MADCOL_Ph3-AccCtrl-01: The security information model should support authorization of performance metrics.
4.1.1.4 Potential Solution
4.4 Clarification of Mechanisms to Discover, Request and Retrieve Management Data
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 4.4.1 Use Case#4-1: Enhancement of Management data collection
| 4.4.1.1 Description
The ManagementDataCollection IOC defined in TS 28.622 [2] represents a management data collection request job for trace metrics and performance metrics. The ManagementDataCollection IOC includes attributes “managementData”, “targetNodeFilter”, “collectionTimeWindow”, “reportingCtrl”, “dataScope”, “condition”, “processMonitor”, “consolidateOutput” and “jobId”. For the performance metrics (including performance measurements and KPIs), different MnS consumers may have different requirements for the granularity period used to report and produce performance metrics.
4.4.1.2 Problem Statement
In current definition for ManagementDataCollection IOC, it is not clear how the granularity period for data production using PerfMetricJob IOC (which include the mandatory attribute “granularityPeriod”) can be derived from a ManagementDataCollection IOC.
4.1.1.3 Potential Requirements
TBD
4.1.1.4 Potential Solution
TBD
|
be084ca539ec241ad52e3fcedfa78679 | 28.887 | 5 Conclusion and Recommendations
| Editor’s Note: This clause is to summarize the identified key items and to discuss recommendations for a potential Work Item.
5.1 Request and Report of External Management Data
5.2 UE Data Collection
5.3 Enhancement of Management Services Access Control (MSAC)
5.4 Clarification of Mechanisms to Discover, Request and Retrieve Management Data
Annex A (informative):
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-08
SA5#162
Initial skeleton
V0.0.0
2025-08
SA5#162
S5-253500
Pseudo-CR on Time Issue of External Management Data
0.1.0
2025-08
SA5#162
S5-254047
Pseudo-CR on TR structure for 28.887
0.1.0
2025-10
SA5#163
S5-254894
Pseudo-CR on Introduction for data management phase-3
0.2.0
2025-10
SA5#163
S5-254895
Pseudo-CR on Scope for data management phase-3
0.2.0
2025-10
SA5#163
S5-254689
Pseudo-CR on Time Issue of External Management Data
0.2.0
2025-11
SA5#164
S5-255561
Pseudo-CR on Add use case and requirements on access control for data
0.3.0
2025-11
SA5#164
S5-255563
Pseudo-CR on TR 28.887 enhancement of Management data collection
0.30
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 1 Scope
| The present document …
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 38.300: "NR and NG-RAN Overall Description; Stage 2".
[3] 3GPP TR 38.843: " Study on Artificial Intelligence (AI)/Machine Learning (ML) for NR air interface ".
[4] 3GPP TS 28.105 "Management and orchestration; Artificial Intelligence / Machine Learning (AI/ML) management".
[5] RP-221348: "Study on Artificial Intelligence (AI) / Machine Learning (ML) for NR air interface (FS_NR_AIML_air)".
[6] SP-241567: "Study on AI/ML management – phase 2 (FS_AIML_MGT_Ph2) ".
[7] TR 28.858: "Study on Artificial Intelligence (AI) / Machine Learning (ML) management phase 2", v19.0.0 (2025-01).
[8] RAN1#120 meeting Chair Notes (https://www.3gpp.org/ftp/tsg_ran/wg1_rl1/tsgr1_120/inbox/chair_notes/chair%20notes%20ran1%2023120%20eom1.zip).
[9] 3GPP TS 28.310 "Management and orchestration; Energy efficiency of 5G".
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 3 Definitions of terms, symbols and abbreviations
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
OTT Over the top
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 4 Concepts and overview
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5 Management capabilities for AI/ML lifecycle
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1 ML model training
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1 Use cases
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1 Management support to training for UE-side model
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1.1 Management support to AI/ML-based beam management
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1.1.1 Description
| To support AI/ML-based beam management defined in TS 38.300 [2], for beam prediction management, UE can send the data of beam prediction management to UE-side training entity (e.g. a server inside MNO or an OTT server) via gNB and 3GPP management system for UE-side model training (see NOTE 1). 3GPP management system needs to collect data from gNB and report it to UE-side training entity to management support of training for UE-side model.
Figure 5.1.1.1.1.1-1: Management of UE-side data collection and reporting for UE-side model training
Being a MnS consumer, the UE-side training entity requests 3GPP management system to collect the UE-side data of beam prediction management, then 3GPP management system configure the gNB(s) to collects data from specified UEs, and gNB shall send configuration information to the UE(s). The request from UE-side training entity shall include the type of data (e.g. based on UE/UE Group, location, time) to be produced and the gNB(s) where the data shall be collected.
After the UE-side training data such as beam prediction data are produced, UE(s) shall report the UE-side data to gNB(s), and 3GPP management system shall collect data from the gNB(s). 3GPP management system report the collected data to UE-side training entity depending on access information specified by operator (see NOTE 2).
NOTE 1: The UE-side data are subject to further discussion, pending ongoing correspondence and confirmation by RAN2 and RAN1.
NOTE 2: Access control information is for further discussion.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1.1.2 Potential requirements
| REQ-ML_UESIDE-01: The 3GPP management system should have a capability allowing the authorized UE-side training entity to request the UE-side training data for the UE-side model training.
REQ-ML_UESIDE-02: The 3GPP management system should have a capability to request and get the UE-side training data from gNB(s) for the UE-side model training.
REQ-ML_UESIDE-03: The 3GPP management system should have a capability to report the UE-side data to authorized UE-side training entity for UE-side model training.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1.1.3 Possible solutions
| TBD
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.1.1.4 Possible solutions evaluation
| TBD
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2 Management support to OAM-centric training for NG-RAN NW-side model
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2.1 Management support to AI/ML-based beam management
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2.1.1 Description
| To support AI/ML-based beam management defined in TS 38.300 [2], UE can provide data of beam management to 3GPP management system via gNB (see NOTE 1). 3GPP management system needs to collect data from gNB for OAM-centric training for NG-RAN NW-side model.
Figure 5.1.1.2.1.1-1: Management of NW-side data collection and reporting for NW-side model training
The 3GPP management system request gNB(s) to collect the NW-side training data of beam management and provides the configuration to gNB(s), then gNB(s) shall send configuration information to the UE(s) for NW-side training data collection. After the NW-side training data are produced, UE(s) shall report the NW-side training data to gNB(s), and 3GPP management system shall collect data from the gNB(s). 3GPP management system collect data should depend on access control information specified by operator (see NOTE 2).
NOTE 1: The OAM centric NW-side training data are subject to further discussion, pending ongoing correspondence and confirmation by RAN2.
NOTE 2: Access control information is for further discussion.
Editor notes: The need for user consent is pending ongoing correspondence and confirmation by SA3 and RAN2.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2.1.2 Potential requirements
| REQ-ML_NWSIDE-01: The 3GPP management system should have a capability to configure the NW-side training data collection for OAM-centric NW-side model training.
REQ-ML_NWSIDE-02: The 3GPP management system should have a capability to obtain the NW-side training data for OAM-centric NW-side model training.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2.1.3 Possible solutions
| TBD
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.2.1.4 Possible solutions evaluation
| TBD
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.3 Management of Vertical Federated Learning
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.3.1 Description
| In Rel-19, Vertical Federated Learning (VFL) is introduced in core network for NWDAF(s) and AF(s).There may be one NWDAF or one AF acting as a VFL server and one or multiple NWDAF(s) and/or one or multiple AF(s) acting as VFL Client(s). Vertical Federated Learning is available among NWDAFs or between NWDAF(s) and AF(s) within a single PLMN or between an AF and NWDAF(s) in a single PLMN. When AF is acting as VFL Server, NWDAF(s) is VFL Client(s).
In Rel-19, federated learning is introduced in the 3GPP management system for multiple ML training functions. The MnS Consumer can specify the FL Requirements in ML Training Request for FL process, where the FLClientSelectionCriteria including the consumer’s requirements on sample (e.g., minimumAvailableDataSamples) for clients selection. However, current mechanism doesn’t allow the consumer to specify requirements on feature for client selection in VFL process. Since HFL and VFL are two distinct paradigms within the broader framework of FL, in VFL process, participants possess different feature space for potentially overlapping samples, which is ideal and beneficial to be introduced in management system. Since the MLTFunctions within the operator domain may be located in cross-domain management system, RAN domain management system and Core domain management system, available datasets for these MLTFunctions may share common samples but offer complementary features. The sample alignment is needed to ensure that different VFL participators share the same sample space before initiating VFL process.
The model training approach for HFL and VFL is also different. Training method allows each VFL Client owning its own local model but not needing to share the same model architectures, since different feature space in VFL Clients may lead to different structures for local models. But the intermediate information of the interaction is implementation specific. The VFL training architecture is fully applicable to the characteristics of management system and can fully exploit the potential of data in management system. This use case proposes to support management of VFL leveraging sample alignment among the entities participating in VFL process.
NOTE 1: The technical details of how the sample alignment is performed, including specific algorithms or mechanisms for matching or encrypting sample identifiers, remain proprietary and are outside of the scope 3GPP SA5.
NOTE 2: The management coordination in VFL process is only applicable within the operator domain.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.3.2 Potential requirements
| REQ-VFL_MGMT-01: The ML training MnS producer should have a capability allowing an authorized consumer to get the VFL role (VFL server or VFL client) of an ML Training Function in VFL process.
REQ-VFL_MGMT-02: The ML training MnS producer should have a capability allowing an authorized consumer to specify requirements on sample alignment for client selection in VFL.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.3.3 Possible solutions
| To support VFL in 3GPP management system, the following enhancements are proposed:
- Enhancements Aspects #1, extending the MLTrainingFunction IOC with the following aspects:
1) Extend learningTechnologyName by changing the allowed value “FL” to “VFL” and “HFL” to differentiate different FL training types supported by the ML Training Function.
2) Extend FLParticipationInfo, by adding a new attribute FLType to indicate the applied FL training types, i.e., HFL or VFL.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.3.4 Possible solutions evaluation
| 5.1.1.4 Management support to data collection for two-sided model training
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.4.1 Management support to CSI compression
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.4.1.1 Description
| To support CSI compression defined in TR 38.843 [3], the operator can deliver relevant data for two-sided model training (see NOTE 1) to a UE-side model training entity (e.g. a server deployed by an MNO or by an OTT service provider). The UE-side model training entity uses the received data to perform UE-part model training for CSI compression.
For this use case, the following approach is considered: gNB -> OAM -> UE-side training entity (a server inside MNO or an OTT server), where the gNB is the data-collection entity for relevant data for two-sided model training.
The operator uses the 3GPP management system to control and supervise how relevant data for CSI compression is delivered to the UE-side training entity (see NOTE 2).
Figure 5.1.1.4.1.1-1 Illustration of data collection for two-side CSI model training
The UE-side training entity sends a subscription request (see NOTE 3) to the 3GPP management system, expressing its interest to receive the data for CSI compression. The UE-side training entity can also include some conditions related to locations (e.g., geographic area) or time (e.g., time windows) for when it expects this data. The 3GPP management system registers this request, which includes the identifier of the UE-side training entity. If the subscribed data is not available at the 3GPP management system, the 3GPP management system then decides from which gNB(s) this data needs to be collected and proceeds with their configuration. Each selected gNB (see NOTE 4) is configured with information that specifies what data this gNB needs to produce for CSI compression, and how this data when available needs to be reported to the 3GPP management system (see NOTE 5). Based on this configuration and the network status, the gNB reports the requested data to the 3GPP management system.
Upon collecting the data from the different gNBs, the management system delivers it to the UE-side training entity based on access control information specified by the operator (see NOTE 2).
NOTE 1: The relevant data for two-side model (see arrows in Figure 5.1.1.4.1.1-1) is subject to further discussion, pending ongoing correspondence and confirmation by RAN2.
NOTE 2: Access control information is for further discussion.
NOTE 3: The term ‘subscription request’ does not specifically imply adoption of a subscribe/notify mechanism in the solution. It is used to capture the requirement that the UE‑side training entity can declare its interest in data delivery.
NOTE 4: The selected gNB(s) support the AI/ML feature for CSI compression use case.
NOTE 5: The UE-side training entity identity is managed by the operator within the 3GPP management system, whether it needs to be included in the configuration for traceability purposes is for further discussion.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.4.1.2 Potential requirements
| REQ-ML_TWOSIDE-01: The 3GPP management system should have a capability allowing a UE-side training entity to subscribe for receiving relevant data for CSI compression.
REQ-ML_TWOSIDE-02: The 3GPP management system should have a capability to configure one or more gNBs to produce and report relevant data for CSI compression.
REQ-ML_TWOSIDE-03: The 3GPP management system should have a capability to deliver relevant data to a subscribed UE-side training entity.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.5 Enhancement on LCM of Federated Learning
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.5.1 Description
| Federated learning (FL) is a distributed machine learning approach that allows multiple FL clients to collaboratively train an ML model on local datasets contained in each FL Client without explicitly exchanging data samples.
When receiving an FL training request, the ML training MnS Producer acting as FL server needs to evaluate the FL specific training requirements such as FL client selection criteria, based on which a FL server has to select appropriate FL clients. FL client selection is a crucial component of FL that directly impacts the performance, efficiency, and fairness of the learning process. However, selecting the optimal set of clients to participate in each round of FL poses several challenges. While some of the requirements are studied in 3GPP to select a FL client but the existing work is not exhaustive enough, especially when it comes to selecting FL clients based on criteria related to renewable energy usage, carbon emission etc. So, it is desirable to consider such aspects also while selecting FL clients so that a sustainable FL based approach can be maintained. Such selection of FL clients by a Producer in FL server can result in overall decreased carbon emission, and reduced non-renewable energy consumption thus promoting overall sustainable development of AI/ML in 5G systems. While FL offers advantages in data privacy, FL introduces significant energy consumption and a substantial carbon footprint from client-side computations. Without energy‑aware client selection, FL can be unsustainable; with it, sustainability can be improved. Hence, there is a need to develop more environmentally friendly and sustainable federated learning mechanisms by addressing the energy consumption inherently in FL.
One of the approaches to achieve environment friendly FL is by promoting and monitoring usage of renewable energy in a FL process. This can be achieved by making design choices that lower non-renewable energy consumption, use more of renewable energy sources and reduce carbon footprint of network. Hence it is important to consider factors like FL client’s renewable energy source, renewable energy consumption and carbon emission of FL client. The approach of energy-aware FL client selection ensuring nodes acting as FL clients have considerable renewable energy usage, suitable renewable energy source and considerably lower carbon emission can practically make a FL system as a sustainable AI practice and contribute to environment which is the need of the hour in any operator’s network.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.5.2 Potential requirements
| REQ-FL_MGMT-01: A ML training function supporting FL should enable a MnS consumer to request for training in consideration of energy information based selection criteria of FL clients.
REQ-FL_MGMT-02: The 3GPP management system should have a capability allowing an MLTrainingFunction acting as the FL Server to select FL clients based on consumer’s requirements on renewable energy source availability.REQ-FL_MGMT-03: The 3GPP management system should have a capability allowing an MLTrainingFunction acting as the FL Server to select FL clients based on consumer’s requirements on renewable energy usage percentage.
REQ-FL_MGMT-04: The 3GPP management system should have a capability allowing an MLTrainingFunction acting as the FL Server to select FL clients based on consumer’s requirements on carbon emission of FL client.5.1.1.5.3 Possible solutions
It is proposed to add these criteria of renewable energy availability, renewable energy percentage and carbon emission information as optional attributes in FLClientSelectionCriteria <<dataType>> defined in clause 7.4.22.2 of TS 28.105 [4] to be able to use them as a criteria for selecting the FL clients by the FL server for collaboratively training a ML model in federated learning.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.5.4 Possible solutions evaluation
| The solution described in clause 5.1.1.5.3 is feasible as it just enhances existing NRM i.e. FLClientSelectionCriteria <<dataType>> with information of renewable energy availability, renewable energy percentage and carbon emission and uses them as criteria for FL client selection in a federated learning.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.6 Enhanced RL training with performance targets
| |
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.6.1 Description
| During RL training, a policy is learnt to maximize a reward aggregated over time. The reward function is defined by the producer from a set of targets set by the consumer. The targets include thresholds such as “Call drop rate(CDR) < 1%”, “Call setup success rate (CSSR) > 90%”, but also optimization instructions such as “minimize CDR”, “maximize CSSR”. Together, these are referred to as “RL performance targets”.
On the other hand, the policy is also required to ensure that the network performance does not degrade along certain other KPIs. This can be specified as a set of thresholds referred to as RL performance constraints, in which the consumer may specify its preference on the policy values that should not be violated during training, for the producer to take into consideration while performing RL training. The constraints may be necessary because otherwise, training the RL model aggressively to optimize the target KPIs may result in degradation of other KPIs.
Specifying only the performance constraints does not suffice, because in the absence of performance targets, the producer may learn only to avoid constraint violation.
In 3GPP TS 28.105 [4], only RL performance constraints are specified for online RL training through the attribute RLRequirement.rLPerformanceRequirements of the IOC MLTrainingRequest. RL performance targets are not specified.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.1.1.6.2 Potential requirements
| REQ-ENH_RL_TRAINING-01: The ML training MnS producer should have a capability to allow an authorized MnS consumer to specify the RL performance targets in an ML model training request.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.2 ML model testing
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
b4e3b34fa206f18d0c88d81247788555 | 28.882 | 5.3 AI/ML inference emulation
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.