Today, we’ll look at a crash that occurred when trying to erase an element from a std::set.
The Case of the Crash When Trying to Erase an Element from a std::set
by Raymond Chen
From the article:
rax=000001f565bc046e rbx=000001f589b20340 rcx=000001f565bc046e
rdx=000000e6658feca8 rsi=000001f589b20690 rdi=000001f589b203c0
rip=00007ffdd4726bc4 rsp=000000e6658fec30 rbp=0000388a1713ab55
r8=000001f589b895d0 r9=000001f589b895d0 r10=000001f589000140
r11=0000000000000000 r12=0000000000000001 r13=000000007ffe0385
r14=0000000000000000 r15=000001f589b8f900
LitWare!std::_Tree<std::_Tset_traits<WidgetWatcher *,
std::less<WidgetWatcher *>,
std::allocator<WidgetWatcher *>,0> >::_Eqrange+0x14
[inlined in LitWare!std::_Tree<std::_Tset_traits<
WidgetWatcher *,std::less<WidgetWatcher *>,
std::allocator<WidgetWatcher *>,0> >::erase+0x18]:
00007ffd`d4726bc4 cmp byte ptr [rax+19h],r11b ds:000001f5`65bc0487=??
The stack trace has some information about how we got here.
LitWare!std::_Tree<std::_Tset_traits<Widget *,
std::less<Widget *>,
std::allocator<Widget *>,0> >::_Eqrange+0x14
LitWare!std::_Tree<std::_Tset_traits<Widget *,
std::less<Widget *>,
std::allocator<Widget *>,0> >::erase+0x18
LitWare!Widget::~Widget+0xc8
LitWare!Widget::`scalar deleting destructor'+0x14
LitWare!DestroyWidget+0x15
Fabrikam!Doodad::~Doodad+0x75
Fabrikam!Doodad::`scalar deleting destructor'+0x14
Fabrikam!Doodad::Release+0x40
Contoso!Gadget::~Gadget+0x66
ucrtbase!<lambda_⟦...⟧>::operator()+0xa5
ucrtbase!__crt_seh_guarded_call<int>::operator()<⟦...⟧>+0x3b
ucrtbase!__acrt_lock_and_call+0x1c
ucrtbase!_execute_onexit_table+0x3d
Contoso!dllmain_crt_process_detach+0x45
Contoso!dllmain_dispatch+0xe6
ntdll!LdrpCallInitRoutine+0xb0
ntdll!LdrShutdownProcess+0x260
ntdll!RtlExitUserProcess+0x114
kernel32!FatalExit+0xb
ucrtbased!exit_or_terminate_process+0x3a
ucrtbased!common_exit+0x85
ucrtbased!exit+0x16
View the full article
Hey all, Today we've added a new sub-domain under our roof. It is for the official Technical Documentation of Horizon. The files are configured using doxygen. Doxygen is a great tool for generating C++ documentation and we've added some features and tweaked the settings a lot for - Better website readability with JS and Graph Images. Generated Graphs for hierarchical view of the project structures. Generated Call and Caller Graphs for over 8000 functions in the specification. PHP powered (server-sided) search for more control on the code base. Feel free to test drive these features by yourself and have a good time understanding our codebase. New Sub-domain: http://documentation.projecthorizon.xyz/ Example of the documentation with call and caller graphs - Best of luck Sephus
Updated our forum version 5.0.0 to 5.0.3. Upgrade was successful and below are the changes made to the forum codebase. #3871: Disable extensions for recovery mode
#3802: Badges in ACP tables were wrapping
#3824: Fix issue where guest comments hang instead of showing a "pending approval" message
#3843: Removed backgrounds, backdrops and conditionally hid captions from Images Widget
#3865: Force Account Settings page to use any predefined FURLs
#3883: Fix exception when viewing Blog RSS feeds
#3832: Fix issue where banned users still have menu options on mobile
#3902: Filter out empty club field values
#3826: Mitigate Icon Picker Lagginess
- Issue #3594: Big Lag when using the icon picker...
- Issue #3770: Editor icon picker configuration
#3854: Active inbox message titles are no longer dark
#3857: Ensure widgets with custom backgrounds inherit border-radius
#3859: Added ipsBox styles to edit form
#3863: Filter out empty secondary group IDs
#3870: Fix Elasticsearch Similar Content issue
#3881: Fix http links in the privacy page
#3882: Fix exception when editing featured content with images
#3885: Fixed width of avatar on profile page
#3887: Updated gallery stat icons
#3891: Fixed minor UI issue in Messenger
#3892: Fixed toggling Activity Stream as default
#3893: Improved spacing of edit form inside posts/comments
#3894: Fixed border-radius of loading dialogs
#3895: Fixed spacing in Account Settings
#3896: Fixed the UI of "Drag to upload files.." on tablets
#3898: Fixed some minor UI issues with ModCP and Notifications page
#3864: Forums may not show if last poster has been anonymised.
#3852: Advertisements optimisation
#3844: Removed gridspan and restored htmlId from radioImages
#3840: Fix PII Export XML issue
- Issue #3794: Request PII Data XML file invalid
- Issue #3830: Cannot export PII Data
#3764: Fix issues with importing themes
#3835: Sync content promoted in v4 with featured content in v5
#3838: Catch exceptions in the deletion log
#3839: Hide items from DatabaseNavigation widget if there is no permission to see them
#3842: Improved contrast of form headers in ACP.
#3833: Remove hard-coded ipsWidget--transparent class from builder widgets
#3790: Hide "Featured By" from Our Picks if the member is not available
#3823: Fix issue where all blog comments are moderated
#3792: Improved performance of navigation "More" menu
#3798: Removed stray '>' in includeJS
#3804: Fixed alignment of color settings in Theme Editor
#3812: Fix issue where deleting a menu item did not give the option to publish
#3814: Don’t share config object between instances
#3729: Fix issue where both an address and an online link can show on an event
#3785: Include URL in disk log
#3787: Add can_edit_tags permission to control cover photo permissions for tags
#3820: Made blog/category header UI consistent with other areas of the suite
#3789: Fix incorrect tooltip in ActiveUsers widget
#3821: Bring back the our picks in email setting
#3813: Don't send assignment notifications to the assignee if they are the one assigning
#3793: Fixed an issue where archived posts were not deleted on topic delete
#3327: Modify Stripe gateway to check for test vs live keys based on NEXUS_TEST_GATEWAYS
In today's post, I'll learn how modern C++ can influence the code you write for your embedded system. You will see code using up to C++23. The example I show you below circles around at least two questions I got various times from customers: What is consteval good for? What is that user-defined literal operator, and why should I care?
C++ for Embedded Systems: constexpr and consteval
by Andreas Fertig
From the article:
Chapter One: What is a MAC address?
I teach a lot of classes to customers who are developing embedded systems. That makes sense. I worked for a long time in that domain, and I enjoyed it so much.
One recurring topic is networking. While nowadays we have various different network types and technologies, let's use the Internet Protocol (IP) today. The base of network communication is your Network Interface Card (NIC). Each NIC has a unique Medium Control Address (MAC) assigned. The MAC address is the base layer for everything on top, like TCP/IP.
A MAC address consists of exactly six bytes. One way to represent a MAC address in code is this:
View the full article
Hey everyone, As we push forward and prepare for the first release of Horizon, it is crucial for us to protect and maintain several rules and strict guidelines shaping the code written in the software. Software can't be written without rules and impositions which create a generic and obedient command over the software and its structure. We cannot disobey the logic followed when the application of concepts and philosophies in our software are imposed, and we cannot create transgression when building software. Transgressed software is detrimental to our concerns and will illogically provide us bugs and details of unethical conduct of manner which we cannot permit in software. We want our manner to be behaved and rules to be followed. To help us get to this extensive requirement of identifying flaws and areas for improvement we require a team of reviewers or a Software Review Committee who need to create powerful structures and code of conduct within the developer community. Here are the rules that the committee should seek upon adding to our codebase and its developers alike - [For Core Development]Core development is the foundation and the foothold of the software that agrees with the top and structural "machina" of the software. The architecture of the core creates a founding control and stability over the structures and systems that are created above it. The core decides whether the software is sound, stable and right in its design and architecture, while the structures above give it shape and nothing but little structure to understand its design requirements. The core of the software or the foundations comprise of its kernel, and the additional components that make the kernel work and function as a whole. The kernel provides the system above a large foundation to be built on top of. The system doesn't rely on any underlying architecture except for some libraries and dependencies which are outside the scope of the software being built. The core or foundation of the software will guarantee that the structures above don't fail and are provided with what they require to function. [For Support Development]Support development is the framework and surrounding structure development of software built on top of its core framework. The support developer team will focus on the business requirements of the software not the founding architectural needs or the dependencies. Support architecture is less focused on when building support systems. The need for several features are important in support development such as the Game requirements or the game logic that functions the business needs and the functioning of game components. For example support developers need to focus on features such as - Player objects, Map objects, Search algorithms, Monster behavior and core technology that will help them function. Additional examples include UI related requests to the server, the UI needs to be made functional by implementing support algorithms and features that will enable the functionality on the client. This is the requirement of the Support Developers that the Review Committee should be well aware of. [For Script Development]Script development includes the building of Lua scripts to extend and modify the behavior of the entire software. We have designed scripts to be an extension to almost all parts of Horizon and are welcoming developers to share their ideas on extending areas of the software that we haven't explored yet. For script development, the Lua Review Commitee is a team designated to work with the developers and provide them with the guidelines and help the require to frame and shape Horizon's script codebase. Guidelines For Each Review Committee MemberAs a Review Committee team member you are required to assess the changes (Pull Requests and Merges) that are made by all the core developers and the support developers. We on the review team decide how the software is shaped and how it functions. The Review Committee team will abide by the following rules in reviewing software - Ensuring Architectural Congruence and Systemic Integrity: The committee serves as an agreement on architectural modifications, meticulously evaluating proposed code to ascertain an adherence with the laws and congruence to the overall architectural blueprint of the software. Cultivating Codebase Homogeneity and Maintainability: Through rigorous scrutiny of coding style, conventions, and best practices, the review committee fosters a cohesive and uniform codebase, thereby significantly enhancing its long-term maintainability, reducing cognitive load for developers, and mitigating the accumulation of technical debt. Facilitating Proactive Bug Identification and Mitigation: Functioning as a critical quality assurance layer, the committee diligently examines code for logical flaws, potential edge cases, and latent bugs, thereby enabling the early detection and rectification of defects before they propagate into production environments, ensuring greater software robustness. Promoting Knowledge Dissemination and Collaborative Learning: The review process acts as a vital conduit for the cross-pollination of technical expertise and domain knowledge within the development team, affording opportunities for less experienced members to glean insights from seasoned professionals and fostering a culture of continuous learning and collective ownership of the codebase. Upholding Performance Efficacy and Resource Optimization: The committee critically assesses the efficiency and scalability implications of proposed code changes, identifying potential performance bottlenecks or resource-intensive implementations, thereby ensuring the software operates optimally under anticipated load and minimizes unnecessary resource consumption. Guarding Against Security Vulnerabilities and Ensuring Robustness: A crucial mandate of the review committee is the proactive identification and mitigation of potential security vulnerabilities embedded within the code, safeguarding the application and its data against malicious exploitation and ensuring the overall resilience of the software system. Verifying Test Adequacy and Quality Assurance Protocols: The committee extends its purview to the evaluation of accompanying test suites, ensuring comprehensive test coverage and adherence to established quality assurance protocols, thereby bolstering confidence in the reliability and correctness of the implemented features. Enforcing Adherence to Project Standards and Regulatory Compliance: The review committee plays a pivotal role in ensuring that all code contributions comply with predefined project standards, industry best practices, and any relevant regulatory requirements, thereby mitigating potential legal and operational risks. Serving as a Repository of Collective Wisdom and Best Practices: Over time, the deliberations and decisions of the review committee establish a valuable institutional memory of coding standards, architectural rationale, and effective problem-solving techniques, contributing to the ongoing evolution and refinement of the development process. How to apply?There are 3 review committees in Horizon's Development Team - The Core Review Committee The Support Review Committee The Script Review Committee To apply, send in your application as a personal message to @Sephus here on the forums with the following form filled - Review Committee Application Form Name: Designation: (Which committee are you applying to): Date of Birth: Occupation: Credentials / Qualifications (Work that would make you an ideal candidate for being on the desired review committee): How many days/months/years will you dedicate to our project? (More days are preferred) Best of luck, Sephus
Hey everyone, As we push forward and prepare for the first release of Horizon, it is crucial for us to protect and maintain several rules and strict guidelines shaping the code written in the software. Software can't be written without rules and impositions which create a generic and obedient command over the software and its structure. We cannot disobey the logic followed when the application of concepts and philosophies in our software are imposed, and we cannot create transgression when building software. Transgressed software is detrimental to our concerns and will illogically provide us bugs and details of unethical conduct of manner which we cannot permit in software. We want our manner to be behaved and rules to be followed. To help us get to this extensive requirement of identifying flaws and areas for improvement we require a team of reviewers or a Software Review Committee who need to create powerful structures and code of conduct within the developer community. Here are the rules that the committee should seek upon adding to our codebase and its developers alike - [For Core Development]Core development is the foundation and the foothold of the software that agrees with the top and structural "machina" of the software. The architecture of the core creates a founding control and stability over the structures and systems that are created above it. The core decides whether the software is sound, stable and right in its design and architecture, while the structures above give it shape and nothing but little structure to understand its design requirements. The core of the software or the foundations comprise of its kernel, and the additional components that make the kernel work and function as a whole. The kernel provides the system above a large foundation to be built on top of. The system doesn't rely on any underlying architecture except for some libraries and dependencies which are outside the scope of the software being built. The core or foundation of the software will guarantee that the structures above don't fail and are provided with what they require to function. [For Support Development]Support development is the framework and surrounding structure development of software built on top of its core framework. The support developer team will focus on the business requirements of the software not the founding architectural needs or the dependencies. Support architecture is less focused on when building support systems. The need for several features are important in support development such as the Game requirements or the game logic that functions the business needs and the functioning of game components. For example support developers need to focus on features such as - Player objects, Map objects, Search algorithms, Monster behavior and core technology that will help them function. Additional examples include UI related requests to the server, the UI needs to be made functional by implementing support algorithms and features that will enable the functionality on the client. This is the requirement of the Support Developers that the Review Committee should be well aware of. [For Script Development]Script development includes the building of Lua scripts to extend and modify the behavior of the entire software. We have designed scripts to be an extension to almost all parts of Horizon and are welcoming developers to share their ideas on extending areas of the software that we haven't explored yet. For script development, the Lua Review Commitee is a team designated to work with the developers and provide them with the guidelines and help the require to frame and shape Horizon's script codebase. Guidelines For Each Review Committee MemberAs a Review Committee team member you are required to assess the changes (Pull Requests and Merges) that are made by all the core developers and the support developers. We on the review team decide how the software is shaped and how it functions. The Review Committee team will abide by the following rules in reviewing software - Ensuring Architectural Congruence and Systemic Integrity: The committee serves as an agreement on architectural modifications, meticulously evaluating proposed code to ascertain an adherence with the laws and congruence to the overall architectural blueprint of the software. Cultivating Codebase Homogeneity and Maintainability: Through rigorous scrutiny of coding style, conventions, and best practices, the review committee fosters a cohesive and uniform codebase, thereby significantly enhancing its long-term maintainability, reducing cognitive load for developers, and mitigating the accumulation of technical debt. Facilitating Proactive Bug Identification and Mitigation: Functioning as a critical quality assurance layer, the committee diligently examines code for logical flaws, potential edge cases, and latent bugs, thereby enabling the early detection and rectification of defects before they propagate into production environments, ensuring greater software robustness. Promoting Knowledge Dissemination and Collaborative Learning: The review process acts as a vital conduit for the cross-pollination of technical expertise and domain knowledge within the development team, affording opportunities for less experienced members to glean insights from seasoned professionals and fostering a culture of continuous learning and collective ownership of the codebase. Upholding Performance Efficacy and Resource Optimization: The committee critically assesses the efficiency and scalability implications of proposed code changes, identifying potential performance bottlenecks or resource-intensive implementations, thereby ensuring the software operates optimally under anticipated load and minimizes unnecessary resource consumption. Guarding Against Security Vulnerabilities and Ensuring Robustness: A crucial mandate of the review committee is the proactive identification and mitigation of potential security vulnerabilities embedded within the code, safeguarding the application and its data against malicious exploitation and ensuring the overall resilience of the software system. Verifying Test Adequacy and Quality Assurance Protocols: The committee extends its purview to the evaluation of accompanying test suites, ensuring comprehensive test coverage and adherence to established quality assurance protocols, thereby bolstering confidence in the reliability and correctness of the implemented features. Enforcing Adherence to Project Standards and Regulatory Compliance: The review committee plays a pivotal role in ensuring that all code contributions comply with predefined project standards, industry best practices, and any relevant regulatory requirements, thereby mitigating potential legal and operational risks. Serving as a Repository of Collective Wisdom and Best Practices: Over time, the deliberations and decisions of the review committee establish a valuable institutional memory of coding standards, architectural rationale, and effective problem-solving techniques, contributing to the ongoing evolution and refinement of the development process. How to apply?There are 3 review committees in Horizon's Development Team - The Core Review Committee The Support Review Committee The Script Review Committee To apply, send in your application as a personal message to @Sephus here on the forums with the following form filled - Review Committee Application Form Name: Designation: (Which committee are you applying to): Date of Birth: Occupation: Credentials / Qualifications (Work that would make you an ideal candidate for being on the desired review committee): How many days/months/years will you dedicate to our project? (More days are preferred) Best of luck, Sephus
So today I attempted to create a project which logged the sent and received times of the walking packet from an openkore client. By modifying the openkore client, I timed the packet sending and receiving functions to mark the time in which the emulator could perform a quick calculation (in this example the walking algorithm) and send back a response to the client. By making the character move on the client I achieved multiple responses and ergo the average response time it took for the emulator to achieve a successful transmission of packets from client to server (request) and back to client (response). The openkore was a fresh install and I had only modified a few lines of code. The patch for this file is attached in this post, feel free to use it in your own openkore to check the packet reception times in your emulator 0001-PacketTimer-Patch.patch Doing this tells me how fast our emulator is and whether what we are doing is the right thing. By looking at the data received from this patch, it seems our emulator is quite close to the eAthena emulators. Keep in mind that Horizon is not at all optimized at this point and we will be doing so only in a few releases into the future. Horizon is a very fast emulator and you can see the results in this patch that we're able to meet the qualifications of a competent emulator in the online gaming industry. We're there with the top emulators in the RO emulation scene and the MMORPG world. We're quite competent even in our less optimized, not bug-tested and unreleased codebase. We're quite there with the top few emulators which achieve the importance of providing a platform based on the "competition" element of online gaming. We want our emulator to maximize competition in online gaming and we're making it possible with rigorous efforts as seen in the results today. We can see that we're just off by 0.001 marks. Which is 1 millisecond of time. We are that much closer to competitive online gaming and we can achieve the difference by working on optimizations on the emulator. Horizon also leverages Hyperthreading (or Multithreading) technology, which means that characters are simultaneously processed on our server compared to the one-by-one processing of them in eAthena based servers. For more clarity, take a look at the diagram below - In eAthena servers, characters are loaded and processed one after the other. This can cause an issue in processing thousands of characters online. In Horizon, characters are logged into maps which are divided amongst the threads of the Game Logic Layer (GLL). In the GLL multiple threads process a group of maps. If two players happen to be in different groups, they are processed differently.
The std::map subscript operator ([]) is a convenient but sometimes dangerous feature, as it can create unintended default-constructed entries. By understanding the behavior of various map insertion and lookup methods—such as insert, emplace, try_emplace, and insert_or_assign—developers can write more efficient and predictable code while avoiding unnecessary key-value creations and duplicate lookups.
A Simplified Overview of Ways to Add or Update Elements in a std::map
by Raymond Chen
From the article:
Some time ago, I mentioned how the std::map subscript operator is a dangerous convenience. In that article, I linked to an overview of the insertion emplacement methods, but I’m going to recapture the essential points in a table.¹
In the table below, the discussion of “consumed” or “not consumed” refers to the case that v is an rvalue reference like std::move(something).
We can reorganize the table by effect.
Exercise: Why are the bottom left two boxes blank?View the full article
C++26 introduces pack indexing as a core language feature, making it significantly easier to extract specific elements from parameter packs using a familiar subscript syntax. This improvement, proposed by Corentin Jabot and Pablo Halpern, eliminates the need for cumbersome workarounds like recursive templates or boolean expression tricks, providing a more intuitive and readable approach.
C++26: pack indexing
by Sandor Dargo
From the article:
C++11 introduced parameter packs to provide a safer way to pass an undefined number of parameters to functions instead of relying on variadic functions.
While packs are a useful feature, and since C++17 it’s so easy to use them in fold expressions, extracting a specific element of a pack is somewhat cumbersome.
You either have to rely on some standard functions not made for the purpose or use “awkward boolean expression crafting or recursive templates”. None of them is unbearable, but it might be error-prone or simply expensive regarding compile-time performance. Nevertheless, they are not the most readable solutions.
C++26 brings us pack indexing as a core language feature thanks to the proposal of Corentin Jabot and Pablo Halpern, P2662R3.
Before discussing some interesting points, first, let’s look at an example:
View the full article
On 12th March, 2025 we have reinstalled our runners. Runners are those which compile the project in its development environment and release key data that is crucial to the project's stability and testing. We are testing the project on 6 Linux VMs which compile the codebase in both GCC and Clang environments, each having Debug and Release configurations. Debug and Release configurations are the two different kind of configurations that the project can be compiled in. Debug means the project will hold debug information in its compiled state, while Release means a more optimized version of the software is compiled. Both these configuration was well as RelWithDebInfo are an important configuration for the project to be compiled in each runner pipeline. An example of a runner can be seen inside the laboratory each commit will have a check mark of whether it is passed or failed. Passed indicates a good working state of the project, while fail means a cross mark in red. Both these states are declared by each of the runners. That is why the runners are an important part of the project's development. For example, take a look at the image below - Each job has either passed or failed or is currently being worked on. These are automations which compile the code as and when it is pushed to the repository. Having this in our project simply boosts the quality and performance of the system.
Horizon is now a public software. I went up and down with it a few times thinking that making a paid software out of it was not a priority for me and something that I didn't want to do in the long run because of the kind of work it is. Horizon is a free open source emulator and it should be kept that way for a lot of reasons. I started it as an open source software and so it should be kept as such. The heart of it is an open and free world of code where you can do anything you can dream or imagine. That shouldn't be taken away, the software will grow as it has been parented and taking it away from its free spirited philosophy makes the dream of it become unkept. So in the spirit of its freedom and the services we provide for free in this community, Horizon is back on its feet walking itself into the strength and integrity it needs to run like Forrest Gump ran for his freedom. Horizon's codebase is available at our laboratory - http://lab.projecthorizon.xyz/horizon/horizon Packet parsers, stress testers and Hercules to Horizon packet converters are all available and listed under our group named Horizon.
So after a long time of dealing with a problem in Windows Server 2022, I finally decided to give it up because I can't be bothered to use it if it keeps giving me issues. I've decided to shift to Proxmox. Some of the data has been lost due to Invision Community being a tardy software as well. Images and files uploaded via our forum are gone, we'll need to reupload them. All things in all we managed to upgrade ourselves from the shitty lapse of a software Windows has made itself to Proxmox which is running on Linux. Now I'm converting all my drives to the ext4 format for Linux compatibility. 3 Machines have been transferred and I'm looking to do the rest tomorrow or the day after. A lot of work to be done to keep this community going! I love it! No worries about the work to be done, it's all good. If anything, the site should be much faster due to the lightweight host operating system, kvm benefits and linux host machine hypervisors. Lets hope that this lasts us well a long time unlike Windows which gave up on us 6 months into our production phase.
In this blog post, we’ll explore ways to improve the safety of a simple configuration manager. We’ll handle common pitfalls like dangling references and excessive stack usage. Additionally, we’ll see how C++26 helps enforce safer coding practices with stricter diagnostics and improved handling of large objects.
Improving Code Safety in C++26: Managers and Dangling References
by Bartlomiej Filipek
From the article:
Step 1: The Buggy Implementation
Below is a simple example of a manager object that stores various configs in a map and provides a method to retrieve them. When a requested configuration isn’t found, the code attempts to return a default certificate:
Do you see a potential error in this code?
. . .
At first glance, the code looks harmless. However, if the requested entry isn’t found, the function returns a reference to a temporary std::vector. Once the function exits, that temporary is destroyed—leaving you with a dangling reference and undefined behavior.
View the full article
Last time, we looked at how the Microsoft C++ standard library implements wait and notify_* for std::atomic<std::shared_ptr<T>>. Today, we’ll look at the other library that (as of this writing) implements std::atomic<std::shared_ptr<T>>: libstdc++.
Inside STL: Waiting for a std::atomic<std::shared_ptr<T>> to change, part 2
by Raymond Chen
From the article:
The first thing to note is that the traditional “wait for a value to change” mechanism on unix is the futex, but futexes (futexen?) are limited to 4-byte values, which is insufficient for a 64-bit pointer, much less the two pointers inside a shared_ptr.
At this point, I will refer you to learn about how libstdc++ implements waits on atomic values, particularly the section on how it handles types that do not fit in a __platform_wait_t. The remainder of this discussion will treat that as an already-solved problem and focus on the shared pointer part.
Okay, back to atomic<shared_ptr<T>>::wait():
// atomic<shared_ptr<T>>::wait
void
wait(value_type __old,
memory_order __o = memory_order_seq_cst) const noexcept
{
_M_impl.wait(std::move(__old), __o);
}
When you wait on a shared_ptr, the work is done by _Sp_atomic::wait:
// _Sp_atomic<shared_ptr<T>>::wait
void
wait(value_type __old, memory_order __o) const noexcept
{
auto __pi = _M_refcount.lock(memory_order_acquire);
if (_M_ptr == __old._M_ptr && __pi == __old._M_refcount._M_pi)
_M_refcount._M_wait_unlock(__o);
else
_M_refcount.unlock(memory_order_relaxed);
}
View the full article
The ACCU conference has a range of workshops, including online options, this year:
Workshops for Everyone
by ACCU Conference
From the article:
See all the offerings, from Jason Turner, Nicolai Josuttis, Robert Seacord, Gail Ollis, Mateusz Pusz, Phil Nash and Mike Shah.
View the full article
Should you start new projects in C++, these days? Is language safety an issue for you? What can be done, today?
Making C++ Safer
by Greg Law
From the article:
I believe that over time C++ will become a lot safer, maybe even some kind of ΓÇÿsafeΓÇÖ. Competition is good: Clang was the best thing to happen to GCC, and Rust might turn out to be the best thing to happen to C++. That journey has already begun, with proposals for the evolution of the language including Contracts and Profiles, and simply changing some of the defaults in C++26. While the language custodians work to make the language itself safer, what can you do today?
  View the full article
When using std::atomic<std::shared_ptr<T>>, the C++ standard defines a "change" as a modification to either the stored pointer or the control block pointer. However, since atomic wait mechanisms typically track only a single memory address, the Microsoft implementation handles this limitation by using a timeout-based polling strategy to detect changes in the control block.
Inside STL: Waiting for a std::atomic<std::shared_ptr<T>> to change, part 1
by Raymond Chen
From the article:
Like other std::atomic specializations, std::atomic<std::shared_ptr<T>> supports the wait and notify_* methods for waiting for the value to change and reporting that the value has changed. The definition of “changed” in the C++ language specification is that the value has changed if either the stored pointer or the control block pointer has changed. A shared pointer is implemented as a pair of pointers, but Wait­On­Address can wait on at most 8 bytes, and unix futexes can wait on only four bytes, so how does this work?¹
The Microsoft implementation waits for the stored pointer to change, and the notify_* methods signal the stored pointer. But wait, this fails to detect the case where the stored pointer stays the same and only the control block changes.
std::atomic<std::shared_ptr<int>> p =
std::make_shared<int>(42);
void change_control_block()
{
auto old = p.load();
auto empty = std::shared_ptr<int>();
// Replace with an indulgent shared pointer
// with the same stored pointer.
p.store({ empty, old.get() });
p.notify_all();
}
void wait_for_change()
{
auto old = p.load();
p.wait(old);
}
View the full article
Let me rephrase what I said, If your project is founded on Horizon and is using our software, you are more than welcome to talk about your game dev and emu development but if you're using your own custom project that is entirely different from Ragnarok Online then it is not allowed. Infact I would be more than happy to shortlist this thread in the likes that we can discuss more about it in our community. There may be others who would want to speak about their projects and get help from us.
This issue has resumed, what I analyzed was that Caddy hangs when asked to serve a high load of clients. I think there were a large volume of users concurrently accessing the site in which time the webserver required more RAM than available (2GB at that time.) I've increased this to 4GB past the recent incident in which caddy had stopped resolving requests and just left the browser continuously hanging. Waiting for more data on the new configuration so that we can estimate a resolution for this situation. Edit: Another angle to this problem could be that caddy has memory leaks, still to devise.
Horizon's PTS is used for testing and serving the community with a server that showcases Horizon and its features. The community is welcome to use it for the benefit of testing and finding errors. So lets get down to it - Download the @bio provided Horizon client from here. Change the IP Address in data/clientinfo.xml to 15.235.163.198. Connect using the "_m" or "_f" method. In this method you add a suffix "_m" for male characters or "_f" for female characters to your username in your account creation for only the first time and only during account creation. The next time you log in you don't need to add this suffix to your username. That's it, you're connected to the PTS and you can start playing on a Horizon powered server. Watch the following video which showcases the login and registration process - Screen Recording 2025-03-01 143407.mp4
_dd6542.png)
_8304fa.png)
The 2025-03 mailing of new standards papers is now available. WG21 Number Title Author Document Date Mailing Date Previous Version Subgroup N5004 2025 Sofia Meeting Invitation and Information Vassil Vassilev 2025-01-14 2025-03 All of WG21 N5005 WG21 2025-01 Hagenberg Admin telecon minutes Nina Ranns 2025-01-31 2025-03 All of WG21 N5006 2025 WG21 admin telecon meetings (revised 2025-02-20) Herb Sutter 2025-03-03 2025-03 All of WG21 N5007 WG21 02/2025 Hagenberg Minutes of Meeting Nina Ranns 2025-03-03 2025-03 All of WG21 N5008 Working Draft, Programming Languages -- C++ Thomas Köppe 2025-03-15 2025-03 All of WG21 N5009 Editors' Report, Programming Languages -- C++ Thomas Köppe 2025-03-15 2025-03 All of WG21 P0260R15 C++ Concurrent Queues Detlef Vollmann 2025-02-13 2025-03 P0260R14 SG1 Concurrency and Parallelism,LEWG Library Evolution P0260R16 C++ Concurrent Queues Detlef Vollmann 2025-02-15 2025-03 P0260R15 SG1 Concurrency and Parallelism,LEWG Library Evolution P0876R20 fiber_context - fibers without scheduler Oliver Kowalke 2025-02-27 2025-03 P0876R19 EWG Evolution,CWG Core,LWG Library P1494R5 Partial program correctness S. Davis Herring 2025-03-04 2025-03 P1494R4 CWG Core,LWG Library P1967R14 #embed - a simple, scannable preprocessor-based resource acquisition method JeanHeyd Meneide 2025-02-17 2025-03 P1967R13 CWG Core P2079R7 System execution context Lucian Radu Teodorescu 2025-02-12 2025-03 P2079R6 LEWG Library Evolution P2287R4 Designated-initializers for base classes Barry Revzin 2025-03-10 2025-03 P2287R3 EWG Evolution P2414R6 Pointer lifetime-end zap proposed solutions Paul E. McKenney 2025-02-13 2025-03 P2414R5 SG1 Concurrency and Parallelism,LEWG Library Evolution,LWG Library P2663R7 Proposal to support interleaved complex values in std::simd Daniel Towner 2025-02-17 2025-03 P2663R6 LWG Library P2719R4 Type-aware allocation and deallocation functions Louis Dionne 2025-02-10 2025-03 P2719R3 CWG Core P2758R5 Emitting messages at compile time Barry Revzin 2025-03-16 2025-03 P2758R4 CWG Core,LWG Library P2781R6 std::constexpr_wrapper Zach Laine 2025-02-16 2025-03 P2781R5 LEWG Library Evolution,LWG Library P2781R7 std::constexpr_wrapper Zach Laine 2025-03-09 2025-03 P2781R6 LEWG Library Evolution,LWG Library P2781R8 std::constexpr_wrapper Zach Laine 2025-03-15 2025-03 P2781R7 LEWG Library Evolution,LWG Library P2786R12 Trivial Relocatability For C++26 Pablo Halpern 2025-02-10 2025-03 P2786R11 CWG Core,LWG Library P2786R13 Trivial Relocatability For C++26 Pablo Halpern 2025-02-14 2025-03 P2786R12 All of WG21 P2825R5 Overload resolution hook: declcall( unevaluated-call-expression ) Gašper Ažman 2025-03-16 2025-03 P2825R4 EWG Evolution,CWG Core P2830R10 Standardized Constexpr Type Ordering Gašper Ažman 2025-03-15 2025-03 P2830R9 EWG Evolution,LEWG Library Evolution,CWG Core,LWG Library P2841R7 Concept and variable-template template-parameters Corentin Jabot 2025-02-15 2025-03 P2841R6 CWG Core P2843R2 Preprocessing is never undefined Alisdair Meredith 2025-03-17 2025-03 P2843R1 CWG Core P2846R6 reserve_hint: Eagerly reserving memory for not-quite-sized lazy ranges Corentin Jabot 2025-02-15 2025-03 P2846R5 LWG Library P2863R9 Review Annex D for C++26 Alisdair Meredith 2025-03-11 2025-03 P2863R8 EWG Evolution,CWG Core,LWG Library P2873R3 Remove Deprecated locale category facets for Unicode from C++26 Alisdair Meredith 2025-03-17 2025-03 P2873R2 LWG Library P2876R2 Proposal to extend std::simd with more constructors and accessors Daniel Towner 2025-02-14 2025-03 P2876R1 LWG Library P2899R1 Contracts for C++ - Rationale Timur Doumler 2025-03-14 2025-03 P2899R0 SG21 Contracts,EWG Evolution,LEWG Library Evolution P2900R14 Contracts for C++ Joshua Berne 2025-02-14 2025-03 P2900R13 CWG Core,LWG Library P2933R4 std::simd overloads for <bit> header Daniel Towner 2025-02-17 2025-03 P2933R3 LWG Library P2988R10 std::optional<T&> Steve Downey 2025-02-18 2025-03 P2988R9 LWG Library P2988R11 std::optional<T&> Steve Downey 2025-03-17 2025-03 P2988R10 LWG Library P2996R10 Reflection for C++26 Barry Revzin 2025-02-26 2025-03 P2996R9 EWG Evolution P3008R4 Atomic floating-point min/max Gonzalo Brito Gadeschi 2025-02-20 2025-03 P3008R3 LWG Library P3016R6 Resolve inconsistencies in begin/end for valarray and braced initializer lists Arthur O'Dwyer 2025-02-11 2025-03 P3016R5 LWG Library P3019R13 Vocabulary Types for Composite Class Design Jonathan Coe 2025-02-09 2025-03 P3019R12 LEWG Library Evolution,LWG Library P3019R14 Vocabulary Types for Composite Class Design Jonathan Coe 2025-02-11 2025-03 P3019R13 LEWG Library Evolution,LWG Library P3060R2 Add std::views::indices(n) Weile Wei 2025-02-20 2025-03 P3060R1 LWG Library P3070R3 Formatting enums Victor Zverovich 2025-02-16 2025-03 P3070R2 LWG Library P3074R6 trivial unions (was std::uninitialized<T>) Barry Revzin 2025-02-11 2025-03 P3074R5 EWG Evolution P3074R7 trivial unions (was std::uninitialized<T>) Barry Revzin 2025-02-14 2025-03 P3074R6 EWG Evolution P3081R2 Core safety profiles for C++26 Herb Sutter 2025-02-03 2025-03 P3081R1 EWG Evolution,LEWG Library Evolution P3096R6 Function Parameter Reflection in Reflection for C++26 Adam Lach 2025-02-07 2025-03 P3096R5 CWG Core,LWG Library P3096R7 Function Parameter Reflection in Reflection for C++26 Adam Lach 2025-03-15 2025-03 P3096R6 CWG Core,LWG Library P3104R3 Bit permutations Jan Schultke 2025-02-11 2025-03 P3104R2 LEWG Library Evolution P3111R4 Atomic Reduction Operations Gonzalo Brito Gadeschi 2025-02-14 2025-03 P3111R3 LEWG Library Evolution P3111R5 Atomic Reduction Operations Gonzalo Brito Gadeschi 2025-02-20 2025-03 P3111R4 CWG Core,LWG Library P3137R3 views::to_input Tim Song 2025-02-10 2025-03 P3137R2 LWG Library P3149R9 async_scope -- Creating scopes for non-sequential concurrency Ian Petersen 2025-02-18 2025-03 P3149R8 LWG Library P3161R3 Unified integer overflow arithmetic Tiago Freire 2025-01-16 2025-03 P3161R2 SG6 Numerics P3179R6 C++ parallel range algorithms Ruslan Arutyunyan 2025-02-07 2025-03 P3179R5 LEWG Library Evolution P3179R7 C++ parallel range algorithms Ruslan Arutyunyan 2025-02-28 2025-03 P3179R6 LWG Library P3229R1 Making erroneous behaviour compatible with Contracts Timur Doumler 2025-02-10 2025-03 P3229R0 EWG Evolution,LEWG Library Evolution P3230R2 views::unchecked_(take|drop) Hewill Kang 2025-02-27 2025-03 P3230R1 SG9 Ranges,LEWG Library Evolution,LWG Library P3242R1 Copy and fill for mdspan Nicolas Morales 2025-03-13 2025-03 P3242R0 LEWG Library Evolution P3248R3 Require [u]intptr_t Gonzalo Brito Gadeschi 2025-02-10 2025-03 P3248R2 EWG Evolution,LEWG Library Evolution P3284R3 `write_env` and `unstoppable` Sender Adaptors Eric Niebler 2025-02-13 2025-03 P3284R2 LWG Library P3287R3 Exploration of namespaces for std::simd Matthias Kretz 2025-02-13 2025-03 P3287R2 LWG Library P3296R4 let_async_scope Anthony Williams 2025-03-17 2025-03 P3296R3 LWG Library P3319R3 Add an iota object for simd (and more) Matthias Kretz 2025-02-03 2025-03 P3319R2 LEWG Library Evolution P3319R4 Add an iota object for simd (and more) Matthias Kretz 2025-02-14 2025-03 P3319R3 LEWG Library Evolution P3319R5 Add an iota object for simd (and more) Matthias Kretz 2025-02-14 2025-03 P3319R4 LWG Library P3331R1 Accessing The First and Last Elements in Associative Containers Nikita Sakharin 2025-02-05 2025-03 P3331R0 LEWG Library Evolution,LWG Library P3349R1 Converting contiguous iterators to pointers Jonathan Wakely 2025-02-10 2025-03 P3349R0 LWG Library P3365R1 Remove the Deprecated iterator Class Template from C++26 Alisdair Meredith 2025-03-11 2025-03 P3365R0 LWG Library P3366R1 Remove Deprecated Atomic Initialization API from C++26 Alisdair Meredith 2025-03-16 2025-03 P3366R0 LWG Library P3367R4 constexpr coroutines Hana Dusíková 2025-02-17 2025-03 P3367R3 CWG Core,LWG Library P3372R3 constexpr containers and adapters Hana Dusíková 2025-02-11 2025-03 P3372R2 LWG Library P3378R2 constexpr exception types Hana Dusíková 2025-02-11 2025-03 P3378R1 LWG Library P3383R2 mdspan.at() Stephan Lachnit 2025-02-17 2025-03 P3383R1 LWG Library P3385R4 Attributes reflection Aurelien Cassagnes 2025-03-10 2025-03 P3385R3 SG7 Reflection,EWG Evolution,LEWG Library Evolution P3394R2 Annotations for Reflection Daveed Vandevoorde 2025-03-14 2025-03 P3394R1 CWG Core,LWG Library P3395R1 Fix encoding issues and add a formatter for std::error_code Victor Zverovich 2025-03-12 2025-03 P3395R0 LEWG Library Evolution P3395R2 Fix encoding issues and add a formatter for std::error_code Victor Zverovich 2025-03-17 2025-03 P3395R1 LEWG Library Evolution P3400R1 Specifying Contract Assertion Properties with Labels Joshua Berne 2025-02-28 2025-03 P3400R0 SG21 Contracts,All of WG21 P3417R1 Handling exceptions thrown from contract predicates Gašper Ažman 2025-03-05 2025-03 P3417R0 SG21 Contracts,EWG Evolution P3430R3 simd issues: explicit, unsequenced, identity-element position, and members of disabled simd Matthias Kretz 2025-02-13 2025-03 P3430R2 LWG Library P3441R1 Rename simd_split to simd_chunk Daniel Towner 2025-01-29 2025-03 P3441R0 LEWG Library Evolution P3441R2 Rename simd_split to simd_chunk Daniel Towner 2025-01-30 2025-03 P3441R1 LEWG Library Evolution P3442R1 [[invalidate_dereferencing]] attribute Patrice Roy 2025-02-11 2025-03 P3442R0 SG14 Low Latency,LEWG Library Evolution P3471R3 Standard Library Hardening Konstantin Varlamov 2025-02-13 2025-03 P3471R2 SG23 Safety and Security,LEWG Library Evolution P3471R4 Standard Library Hardening Konstantin Varlamov 2025-02-14 2025-03 P3471R3 CWG Core,LWG Library P3472R1 Make fiber_context::can_resume() const Andrzej Krzemieński 2025-01-28 2025-03 P3472R0 LEWG Library Evolution P3475R2 Defang and deprecate memory_order::consume Hans Boehm 2025-02-25 2025-03 P3475R1 SG1 Concurrency and Parallelism,EWG Evolution,LEWG Library Evolution,CWG Core,LWG Library P3477R3 There are exactly 8 bits in a byte JF Bastien 2025-02-10 2025-03 P3477R2 LEWG Library Evolution,CWG Core,LWG Library P3477R4 There are exactly 8 bits in a byte JF Bastien 2025-02-13 2025-03 P3477R3 CWG Core P3477R5 There are exactly 8 bits in a byte JF Bastien 2025-03-15 2025-03 P3477R4 EWG Evolution,LEWG Library Evolution P3480R4 std::simd is a range Matthias Kretz 2025-02-14 2025-03 P3480R3 LEWG Library Evolution P3481R2 std::execution::bulk() issues Lucian Radu Teodorescu 2025-02-11 2025-03 P3481R1 LEWG Library Evolution P3482R1 Design for C++ networking based on IETF TAPS Thomas Rodgers, Woven By Toyota, [email protected] 2025-01-13 2025-03 P3482R0 SG4 Networking P3491R2 define_static_{string,object,array} Barry Revzin 2025-03-14 2025-03 P3491R1 EWG Evolution,LEWG Library Evolution P3492R1 Sized deallocation for placement new Lauri Vasama 2025-02-10 2025-03 P3492R0 EWG Evolution P3492R2 Sized deallocation for placement new Lauri Vasama 2025-02-17 2025-03 P3492R1 EWG Evolution,CWG Core P3499R1 Exploring strict contract predicates Timur Doumler 2025-02-09 2025-03 P3499R0 EWG Evolution P3500R1 Are Contracts "safe"? Timur Doumler 2025-02-09 2025-03 P3500R0 EWG Evolution P3503R1 Make type-erased allocator use in promise and packaged_task consistent Nicolas Morales 2025-03-16 2025-03 P3503R0 LWG Library P3503R2 Make type-erased allocator use in promise and packaged_task consistent Nicolas Morales 2025-03-17 2025-03 P3503R1 LWG Library P3505R0 Fix the default floating-point representation in std::format Victor Zverovich 2025-03-16 2025-03 LEWG Library Evolution P3516R1 Uninitialized algorithms for relocation Louis Dionne 2025-02-11 2025-03 P3516R0 LEWG Library Evolution P3526R0 Container truncation Peter Bindels 2025-03-17 2025-03 LEWG Library Evolution P3533R2 constexpr virtual inheritance Hana Dusíková 2025-02-17 2025-03 P3533R1 CWG Core P3537R1 Presentation on Concurrent Queue API Detlef Vollmann 2025-02-11 2025-03 P3537R0 All of WG21 P3540R1 #embed Parameter offset JeanHeyd Meneide 2025-02-17 2025-03 P3540R0 CWG Core P3544R0 ranges::to view Hewill Kang 2025-02-11 2025-03 SG9 Ranges P3547R1 Modeling Access Control With Reflection Dan Katz 2025-02-09 2025-03 P3547R0 SG7 Reflection,EWG Evolution,LEWG Library Evolution,LWG Library P3552R1 Add a Coroutine Task Type Dietmar Kühl 2025-03-16 2025-03 P3552R0 SG1 Concurrency and Parallelism,LEWG Library Evolution P3556R0 Input files are source files Alisdair Meredith 2025-03-17 2025-03 CWG Core P3557R1 High-Quality Sender Diagnostics with Constexpr Exceptions Eric Niebler 2025-02-13 2025-03 P3557R0 LEWG Library Evolution P3558R1 Core Language Contracts By Default Joshua Berne 2025-02-02 2025-03 P3558R0 SG21 Contracts,SG23 Safety and Security P3561R1 Index based coproduct operations on variant, and library wording Esa Pulkkinen 2025-01-16 2025-03 P3561R0 LEWGI SG18: LEWG Incubator P3568R1 break label; and continue label; Jan Schultke 2025-03-13 2025-03 P3568R0 SG22 Compatibility,EWG Evolution P3570R0 optional variants in sender/receiver Fabio Fracassi 2025-02-10 2025-03 LEWG Library Evolution P3579R1 Fix matching of non-type template parameters when matching template template parameters Matheus Izvekov 2025-02-10 2025-03 P3579R0 CWG Core P3589R1 C++ Profiles: The Framework Gabriel Dos Reis 2025-02-03 2025-03 P3589R0 EWG Evolution P3591R0 Contextualizing Contracts Concerns Joshua Berne 2025-02-03 2025-03 SG21 Contracts,EWG Evolution,LEWG Library Evolution P3592R0 Resolving Concerns with const-ification Joshua Berne 2025-02-10 2025-03 SG21 Contracts,EWG Evolution P3599R0 Initial Implicit Contract Assertions Joshua Berne 2025-02-03 2025-03 SG21 Contracts,SG23 Safety and Security,EWG Evolution P3603R0 Consteval-only Values and Consteval Variables Barry Revzin 2025-03-13 2025-03 EWG Evolution P3605R0 isqrt: A function to calculate integer square root of the nonnegative integer Nikita Sakharin 2025-02-05 2025-03 LEWGI SG18: LEWG Incubator,LEWG Library Evolution,LWG Library P3606R0 On Overload Resolution, Exact Matches and Clever Implementations Corentin Jabot 2025-01-27 2025-03 EWG Evolution P3608R0 Contracts and profiles: what can we reasonably ship in C++26 Ville Voutilainen 2025-02-01 2025-03 EWG Evolution,LEWG Library Evolution P3611R0 Dealing with pointer errors: Separating static and dynamic checking Bjarne Stroustrup 2025-02-04 2025-03 SG23 Safety and Security,EWG Evolution,LEWG Library Evolution P3613R0 On the beating of horses, and other matters Tim Song 2025-03-17 2025-03 SG9 Ranges P3614R0 Do not remove nor postpone access_context::unchecked Ville Voutilainen 2025-02-06 2025-03 EWG Evolution P3615R0 C++ Standard Library Ready Issues to be moved in Hagenberg, Feb. 2025 Jonathan Wakely 2025-02-07 2025-03 All of WG21 P3616R0 Remove contracts on virtual functions for now Ville Voutilainen 2025-02-08 2025-03 EWG Evolution P3618R0 Allow attaching main to the global module Michael Spencer 2025-02-11 2025-03 EWG Evolution P3619R0 Counter-examples for P2688R5 Vlad Serebrennikov 2025-02-10 2025-03 EWG Evolution P3619R1 Counter-examples for P2688R5 Vlad Serebrennikov 2025-02-12 2025-03 P3619R0 EWG Evolution P3620R0 Concerns with the proposed addition of fibers to C++ 26 David Chisnall 2025-02-10 2025-03 EWG Evolution,CWG Core,LWG Library P3623R0 Add noexcept to [iterator.range] (LWG 3537) Arthur O'Dwyer 2025-02-11 2025-03 LWG Library P3625R0 either neither Michael Florian Hava 2025-02-11 2025-03 LEWG Library Evolution P3626R0 Make predicate exceptions propagate by default Timur Doumler 2025-02-11 2025-03 EWG Evolution P3627R0 Easy-to-adopt security profiles for preventing RCE (remote code execution) in existing C++ code Ulfar Erlingsson 2025-02-11 2025-03 SG23 Safety and Security P3628R0 break label; and continue label;, tl; dr Jan Schultke 2025-02-12 2025-03 EWGI SG17: EWG Incubator P3630R0 Slides for P3568R0 Jan Schultke 2025-02-12 2025-03 EWG Evolution P3632R0 P3564R0: Make the concurrent forward progress guarantee usable in bulk Mark Hoemmen 2025-02-13 2025-03 SG1 Concurrency and Parallelism P3632R1 P3564R0: Make the concurrent forward progress guarantee usable in bulk Mark Hoemmen 2025-02-13 2025-03 P3632R0 SG1 Concurrency and Parallelism P3633R0 A Byte is a Byte Murat Can Cagri 2025-02-13 2025-03 EWG Evolution,LEWG Library Evolution P3635R0 We shouldn't rush to require either CHAR_BIT==8 or (u)intNN_t Nevin Liber 2025-02-13 2025-03 EWG Evolution,LEWG Library Evolution P3636R0 LEWG Hagenberg presentation for P3581 No, inplace_vector shouldn't have an Allocator Nevin Liber 2025-02-13 2025-03 LEWG Library Evolution P3637R0 Inherit std::meta::exception from std::exception Victor Zverovich 2025-03-08 2025-03 LEWG Library Evolution P3638R0 Core Language Working Group "ready" Issues for the February, 2025 meeting Jens Maurer 2025-02-14 2025-03 CWG Core P3639R0 The _BitInt Debate Jan Schultke 2025-02-20 2025-03 SG6 Numerics,EWG Evolution,LEWG Library Evolution P3640R0 Make contracts reliable by default Jonas Persson 2025-03-17 2025-03 SG21 Contracts,SG23 Safety and Security,EWG Evolution P3641R0 Rename std::observable to std::observable_checkpoint, and add a feature-test macro Jan Schultke 2025-03-13 2025-03 LEWG Library Evolution P3642R0 Carry-less product: std::clmul Jan Schultke 2025-03-13 2025-03 SG6 Numerics,LEWGI SG18: LEWG Incubator P3643R0 std::to_signed and std::to_unsigned Jan Schultke 2025-03-13 2025-03 LEWG Library Evolution P3650R0 21st Century C++ Bjarne Stroustrup 2025-03-05 2025-03 All of WG21 P3651R0 Note to the C++ standards committee members Bjarne Stroustrup 2025-03-06 2025-03 All of WG21 P3652R0 Constexpr floating-point <charconv> functions Lénárd Szolnoki 2025-03-15 2025-03 LEWGI SG18: LEWG Incubator,LEWG Library Evolution P3654R0 Slides for P3516 Giuseppe D'Angelo 2025-03-09 2025-03 LEWG Library Evolution P3655R0 zstring_view Peter Bindels 2025-03-17 2025-03 LEWG Library Evolution P3656R0 Initial draft proposal for core language UB white paper: Process and major work items Herb Sutter 2025-03-11 2025-03 EWG Evolution P3657R0 A Grammar for Whitespace Characters Alisdair Meredith 2025-03-17 2025-03 CWG Core P3658R0 Adjust identifier following new Unicode recommendations Robin Leroy 2025-03-13 2025-03 SG16 Unicode P3660R0 Improve `reference_wrapper` Ergonomics Jeremy Rifkin 2025-03-17 2025-03 LEWGI SG18: LEWG Incubator View the full article
My favorite parts of the technical documentation of Horizon.
Ntrl joined the community
AniPlus joined the community
Thanks. They are not receiving anymore application. I was busy with some tasks off the net
Horizon's PTS is used for testing and serving the community with a server that showcases Horizon and its features. The community is welcome to use it for the benefit of testing and finding errors. So lets get down to it - Download the @bio provided Horizon client from here. Change the IP Address in data/clientinfo.xml to 15.235.163.198. Connect using the "_m" or "_f" method. In this method you add a suffix "_m" for male characters or "_f" for female characters to your username in your account creation for only the first time and only during account creation. The next time you log in you don't need to add this suffix to your username. That's it, you're connected to the PTS and you can start playing on a Horizon powered server. Watch the following video which showcases the login and registration process - Screen Recording 2025-03-01 143407.mp4.webp.e30d82055434d9f9fda5bc8089cba628.webp)
