- SAP Community
- Products and Technology
- Additional Blogs by SAP
- BSP Programming: GEN BRANCHOFFSET LIMIT REACHED
Additional Blogs by SAP
Turn on suggestions
Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.
Showing results for
former_member18
Active Contributor
Options
- Subscribe to RSS Feed
- Mark as New
- Mark as Read
- Bookmark
- Subscribe
- Printer Friendly Page
- Report Inappropriate Content
04-25-2005
2:23 AM
From time to time the error message GEN_BRANCHOFFSET_LIMIT_REACHED pops up. It is a very complex problem right from the heart of the ABAP VM. Let us look quickly at why it happens and some ideas to work around the problem. No, there is no patch for this problem.
Background Information
Any (most?) computer languages have typical limitations that play a role in code generation. The ABAP VM is not exception in this case. One such an limitation is that one IF-statement can only jump 32KB of byte code. So effectively, the source code between the IF- and ENDIF-statements, when compiled, must not be more than 32KB of byte code.
And this plays a big role when the Layout of a BSP page is compiled. (The same rules apply for BSP views as well.) For each BSP page, an ABAP class is generated (in the temporary package $TMP). The name is very criptic, as it constructed from with a GUID (global unique identifier). For example: CL_O2D7QDB5488MACT6YI2S549GQVB.
In the generated class, for the complete layout, source code isgenerated into one method. The event handlers (OnCreate, OnInitialization, etc) are also placed into separate methods on the same class. In this way, each BSP page is translated into a self contained ABAP class, that is generated and instantiated in one step.
So what the problem effectively states, is that somewhere within a method, there is an IF-statement that has a body that exceeds the jump limitations of the ABAP VM. To understand the problem better, we have to look a little bit at how source code generation is done in BSP.
BSP Source Code Generation
Let us assume a simple BSP page with the following source code:
<!
<!
<!
<!
<!
<!
<!
<!
This program shows one technique how an IF-statement can appear within the generated source code. The complete source code (in slightly abstract format) will be:
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
</pre>
<p>The very first interesting aspect is that all static HTML in the BSP page is stored separately in the database, and dynamically loaded at runtime into one string (_m_html). Any static HTML sequence, independent of length, is translated into print statement.</p>
<p>ABAP code within the BSP page is emitted verbatim. BSP print sequences (<%=...%>) are translated to code that first forces the value to a string (effectively using ABAP assign statement), and then just prints the string.</p>
<p>In this example, the generated source code reflects very much the source code that was written on the BSP page, and there is a relationship between the length of the written layout code and the generated source code.</p>
<p>Let us look at a slightly more complex example, where a few BSP tags are used on a page:</p>
<pre>
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
This simplest of simple examples, already generate rather complex code. The reason for this is in the specification of the BSP elements themselves. To allow a flexible architecture, BSP elements can dynamically decide a number of aspects. First, let us look at the generated source for the example (extremely stripped!):
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
The complexity of this source code comes from the fact that the BSP compiler does not know before hand whether a specific BSP element wishes to process its own body (inner BSP elements), or wish to just over the body. The BSP element can decide this during its DO_AT_BEGINNING( ) method. Therefore the BSP compiler generates the IF-statements to test for this condition.
The use of BSP elements is the second source of IF-statements on a BSP page.
Effectively the problem is that the complete layout of one BSP page is placed into one method in a class. And this method now has in its generated form an IF statement that is too large. Any solution must attempt to remove some code from the generated method (which means directly from the layout) and place it somewhere else. Below are three typical approaches that are recommended.
Solution Idea: Use Class Methods to Reduce Layout Code
<p>Probably the simplest technique would be to strip code from the layout of the BSP page, and to place it into a method of class.</p>
<p>Very important:</i> Long sequences of HTML on a page does not make much of a difference in the generated source of the method. The complete HTML sequence is replaced with out print_string statement to start at an offset and dump the string for a specific length.</p>
<p>For such work, one should look at large blocks of program code (<%...%> sequences), or for large blocks of print code (<%= .. %>). Each of these interrupts the HTML, which causes the print_string statement to be splitted into a large number of print_string statements. See the first code generation example above. Let us examine this example code again:</p>
<pre>
<!
<!
<!
<!
<!
<!
<!
<!
</pre>
<p>What we see is that the <%IF...%> sequence, and the <%=sy-uname%> causes many more print_string statements to be emitted, which contributes significantly to the generated code in the layout method.</p>
<p>One solution would be to place this critical code sequence in a separate method. Then the layout code would reduce to:</p>
<pre>
<!
<!
<!
<!
In the above coding, greeting is a method that has a returning parameter of type string. This string is then printed. The method itself would be:
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
</pre>
Solution Idea: Use Smaller Views in MVC to Split Layout Code
The use of methods to contain rendering code works well with HTML code, but comes more complex once BSP extensions are used. Although it is possible process BSP elements inside methods, it is not easy to write and main. Recommended is to split large layouts into separate views. One typical example could be to place the content of each tab in a tabstrip onto a separate view.
Let us start with this example again, with the goal to place the
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
As a first step we create a new view (called my_view.htm) with the displaced content (cut-and-paste from page to view):
<!
<!
<!
<!
<!
<!
<!
On the page main page (or view!), place now a call to a controller that will embed the view. Keep in mind it is not possible to directly expand views in place. See also that we have now added the BSP extension "BSP".
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
As a last step, we create a new controller (my_controller.do). We add one attribute view TYPE string and implement the do_request method:
<!
<!
<!
<!
<!
<!
Passing parameters to different views can also easily be done via the controller.
Recommended Reading:
- [MVC Documentation | http://help.sap.com/saphelp_nw04/helpdata/en/0f/ab3a3c9ca75402e10000000a114084/frameset.htm]
- The BSP example application IT05 uses the above simple controller to embed any number of views.
Solution Idea: Use BSP Element Composition to Bundle BSP Elements
Solution Idea: Replace BSP Element Sequences with Light-Weight Sequences
Often BSP elements are just wrappers around simple HTML sequences. However, we have seen that such BSP elements can cause a large explosion in the generated code. The use of the BSP elements are practical, as the BSP compiler will help to valid that large sequences are correctly nested. However, in cases where the generated source code is to large, ir might help to replace a few of these sequences with native code.
Let us assume this typical form layout example:
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
<!
</pre>
2 Comments
Related Content
- Business Rule Framework Plus(BRF+) in Enterprise Resource Planning Blogs by Members
- CAP LLM Plugin – Empowering Developers for rapid Gen AI-CAP App Development in Technology Blogs by SAP
- Linear programming in ABAP. Simplex method. Find optimised BOM in Technology Blogs by Members
- BENCHMARKING FUJITSU’S DIGITAL ANNEALER TO SOLVE COMPLEX COMBINATORIAL OPTIMIZATION PROBLEMS in Technology Blogs by SAP
- AI-Embedded Flexible Energy Grid: implementation deep dive in Technology Blogs by SAP