Oh no! Where's the JavaScript?
Your Web browser does not have JavaScript enabled or does not support JavaScript. Please enable JavaScript on your Web browser to properly view this Web site, or upgrade to a Web browser that does support JavaScript.

SMP is Working!

Last updated on 5 hours ago
D
danilosJunior Member
Posted 15 hours ago
🚀 AROSA Milestone Reached: SMP is Working!
Today I'm happy to share that AROSA has successfully completed its first SMP (Symmetric Multi-Processing) execution.
This is an early step, but an important one. For the first time, AROSA is successfully utilizing multiple CPU cores and executing work across processors. The screenshot shows the system running with 4 logical processors active while simultaneously handling networking, web browsing, canvas rendering, and system monitoring.
You do not have access to view attachments
T
terminillsMember
Posted 12 hours ago

danilos wrote:

@danilos - 🚀 AROSA Milestone Reached: SMP is Working!
Today I'm happy to share that AROSA has successfully completed its first SMP (Symmetric Multi-Processing) execution.
This is an early step, but an important one. For the first time, AROSA is successfully utilizing multiple CPU cores and executing work across processors. The screenshot shows the system running with 4 logical processors active while simultaneously handling networking, web browsing, canvas rendering, and system monitoring.


AROS has had SMP for years :x
B
BohunDistro Maintainer
Posted 11 hours ago
Does it have libraries that would allow programmers to utilize multiple cores? Programs like the ArtCraft series or browsers don't seem to use SMP?
AROS-ConfidenceAROS-ConfidenceJunior Member
Posted 11 hours ago
Now we need parallel Processing and Memory Protection!
D
danilosJunior Member
Posted 10 hours ago
Yes, AROS already provides APIs that can be used for multicore programming.

At the native level, Exec supports tasks, message ports, signals and synchronization primitives. The SMP implementation also provides CPU-affinity mechanisms, including KrnAllocCPUMask(), KrnGetCPUMask() and SetTaskAffinity(). There is also POSIX threading support.

So the basic mechanisms are there.

However, there is an important distinction between being able to create tasks that run on multiple CPUs and having a complete, stable, SMP-safe environment that applications can reliably exploit.

The main limitation is that not all existing AROS libraries and services are necessarily SMP-safe. For example, Forbid() only prevents task switching on the calling CPU. It does not prevent another CPU from accessing the same shared resources simultaneously. This means traditional Amiga synchronization assumptions cannot always be applied in a multicore environment.

This is particularly relevant to applications such as ArtCraft or browsers. Applications must distribute their workloads, and the operating system services they use must support concurrent execution safely.

This is one of the major objectives of AROSA, and the work involves two complementary levels.

1. Improving the underlying AROS SMP implementation

I have already made several patches to the existing AROS x86_64 SMP kernel while investigating problems encountered during AROSA testing.

The implementation can boot, initialize multiple processors and execute workloads across different CPUs. However, testing has exposed intermittent freezes, locking problems and other stability issues that still require investigation.

I'm continuing to work through scheduling, synchronization and interactions with components designed around single-processor assumptions. Further kernel changes are necessary, and I am not claiming that all these issues have been resolved.

2. Making parallel processing available through AROSA's capability architecture

AROSA is built around a capability consumer/provider model. Rather than requiring applications to depend directly on particular libraries or kernel implementations, functionality is exposed through defined capability contracts and resolved through suitable providers.

This is not merely a theoretical architecture.

ABrowser, ACanvasComposer and AFileManager are concrete examples of applications developed around this capability model. Depending on their roles, components can consume platform capabilities and provide functionality to other components.

ABrowser: Consumes networking, HTML, JavaScript, graphics and media capabilities. Suitable operations, such as decoding and processing, are candidates for parallel execution.

ACanvasComposer: Uses graphics and composition capabilities, providing a natural environment for distributing independent rendering and image-processing workloads.

AFileManager: Consumes filesystem, content and other platform services. File operations such as copying, hashing, compression and processing can potentially be organized as independent jobs.

The significance is that these applications do not each need to implement an entirely separate infrastructure for every shared function.

The same principle applies to multicore execution.

I'm developing the architecture so an application can request a parallel processing capability, submit independent workloads and receive results through a defined interface. AROSA would select an appropriate execution provider, taking account of CPU availability, scheduling requirements and the restrictions of the underlying operating system.

This should eventually allow the same application to use different execution implementations, including a single-core fallback when necessary.

The capability model also integrates with AIDEa, AROSA's application engineering environment, so applications can declare and consume capabilities as part of their composition rather than being tightly coupled to specific system implementations.

Importantly, applications and services can be both consumers and providers. This makes capabilities reusable and allows more complex applications to be assembled from independently implemented components.

However, the higher-level capability model cannot compensate for unsafe kernel behavior. Reliable multicore execution still depends on correct scheduling, locking, synchronization and SMP-safe system interfaces.

That is why I am working on both the underlying AROS kernel and the higher-level AROSA architecture.

The existing applications demonstrate the consumer/provider model, but I am not claiming that all their workloads are already executing in parallel across multiple CPUs. That remains part of the ongoing SMP integration and verification work.

Ultimately, my objective is not simply to demonstrate that AROS can run on several processors. It is to make multicore processing stable, accessible and genuinely useful to application developers.

The goal is to allow applications such as ArtCraft, ABrowser, ACanvasComposer, AFileManager and future AROSA applications to benefit from reusable execution capabilities without requiring every developer to become an expert in kernel scheduling, CPU affinity and synchronization.
T
terminillsMember
Posted 10 hours ago

Bohun wrote:

@Bohun - Does it have libraries that would allow programmers to utilize multiple cores? Programs like the ArtCraft series or browsers don't seem to use SMP?


It's not libraries that are the limiting factor it's API's AROS SMP has specific API's that have worked fine for years.
T
terminillsMember
Posted 10 hours ago

danilos wrote:

@danilos - Yes, AROS already provides APIs that can be used for multicore programming.

At the native level, Exec supports tasks, message ports, signals and synchronization primitives. The SMP implementation also provides CPU-affinity mechanisms, including KrnAllocCPUMask(), KrnGetCPUMask() and SetTaskAffinity(). There is also POSIX threading support.

So the basic mechanisms are there.

However, there is an important distinction between being able to create tasks that run on multiple CPUs and having a complete, stable, SMP-safe environment that applications can reliably exploit.

The main limitation is that not all existing AROS libraries and services are necessarily SMP-safe. For example, Forbid() only prevents task switching on the calling CPU. It does not prevent another CPU from accessing the same shared resources simultaneously. This means traditional Amiga synchronization assumptions cannot always be applied in a multicore environment.

This is particularly relevant to applications such as ArtCraft or browsers. Applications must distribute their workloads, and the operating system services they use must support concurrent execution safely.

This is one of the major objectives of AROSA, and the work involves two complementary levels.

1. Improving the underlying AROS SMP implementation

I have already made several patches to the existing AROS x86_64 SMP kernel while investigating problems encountered during AROSA testing.

The implementation can boot, initialize multiple processors and execute workloads across different CPUs. However, testing has exposed intermittent freezes, locking problems and other stability issues that still require investigation.

I'm continuing to work through scheduling, synchronization and interactions with components designed around single-processor assumptions. Further kernel changes are necessary, and I am not claiming that all these issues have been resolved.

2. Making parallel processing available through AROSA's capability architecture

AROSA is built around a capability consumer/provider model. Rather than requiring applications to depend directly on particular libraries or kernel implementations, functionality is exposed through defined capability contracts and resolved through suitable providers.

This is not merely a theoretical architecture.

ABrowser, ACanvasComposer and AFileManager are concrete examples of applications developed around this capability model. Depending on their roles, components can consume platform capabilities and provide functionality to other components.

ABrowser: Consumes networking, HTML, JavaScript, graphics and media capabilities. Suitable operations, such as decoding and processing, are candidates for parallel execution.

ACanvasComposer: Uses graphics and composition capabilities, providing a natural environment for distributing independent rendering and image-processing workloads.

AFileManager: Consumes filesystem, content and other platform services. File operations such as copying, hashing, compression and processing can potentially be organized as independent jobs.

The significance is that these applications do not each need to implement an entirely separate infrastructure for every shared function.

The same principle applies to multicore execution.

I'm developing the architecture so an application can request a parallel processing capability, submit independent workloads and receive results through a defined interface. AROSA would select an appropriate execution provider, taking account of CPU availability, scheduling requirements and the restrictions of the underlying operating system.

This should eventually allow the same application to use different execution implementations, including a single-core fallback when necessary.

The capability model also integrates with AIDEa, AROSA's application engineering environment, so applications can declare and consume capabilities as part of their composition rather than being tightly coupled to specific system implementations.

Importantly, applications and services can be both consumers and providers. This makes capabilities reusable and allows more complex applications to be assembled from independently implemented components.

However, the higher-level capability model cannot compensate for unsafe kernel behavior. Reliable multicore execution still depends on correct scheduling, locking, synchronization and SMP-safe system interfaces.

That is why I am working on both the underlying AROS kernel and the higher-level AROSA architecture.

The existing applications demonstrate the consumer/provider model, but I am not claiming that all their workloads are already executing in parallel across multiple CPUs. That remains part of the ongoing SMP integration and verification work.

Ultimately, my objective is not simply to demonstrate that AROS can run on several processors. It is to make multicore processing stable, accessible and genuinely useful to application developers.

The goal is to allow applications such as ArtCraft, ABrowser, ACanvasComposer, AFileManager and future AROSA applications to benefit from reusable execution capabilities without requiring every developer to become an expert in kernel scheduling, CPU affinity and synchronization.


I've personally run llamacpp and chromium across 128 cores using dtandard AROS API's what you're doing it trying to add another layer in a sandbox to something that's already being worked on in in master.
D
danilosJunior Member
Posted 9 hours ago
I think we have different goals, and they are not competing goals.

I appreciate the ongoing work on AROS SMP and have no intention of duplicating or diminishing anyone else's efforts.

AROSA is my contribution toward a broader multi-user, multiprocessing, capability-based application and service platform, building on AROS and extending it where necessary.

During development, I have encountered several issues in the x86_64 SMP kernel and have made a number of patches while investigating and correcting them. Some stability issues remain under investigation.

I'm happy to contribute these kernel fixes back to AROS if the developers are interested. I don't know whether I have permission to contribute directly to the repository, but I can certainly make the patches available for review and integration.

I've invested considerable time in AROSA over the past six months, and I'm sharing the work because I believe it could benefit the community.

There is room for different approaches, and I see no reason why they cannot complement each other.

Ultimately, we all want AROS to progress, and I would much rather spend my time developing, testing and sharing improvements than debating competing approaches.
C
coffeecatSoftware Dev
Posted 7 hours ago
You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load
Edited by coffeecat on 19-11-2026 11:20, 7 hours ago
B
BohunDistro Maintainer
Posted 6 hours ago
Please explain to a layman what AROSA is? Is it a program that distributes the threads of a single-core application across multiple cores?
T
terminillsMember
Posted 6 hours ago

coffeecat wrote:

@coffeecat - You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load


The question comes down to is this already being worked on in Master ... if it is this would create two implementations... However the point isn't really about the shared service it's more acting like multicore didn't exist prior to his work which is flat out incorrect.
D
danilosJunior Member
Posted 6 hours ago

coffeecat wrote:

@coffeecat - You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load


Thank you, this is a very interesting observation, and it is much closer to the behavior I have been investigating.

During AROSA testing with four logical processors, AResourceMonitor showed CPU 0 under very heavy load while the other CPUs were active but appeared to contribute comparatively little productive work.

My impression was that some of the processors might be spending a significant amount of time participating in scheduling, synchronization or lock contention rather than executing the actual application workloads.

In other words, the CPUs may be busy coordinating or competing for work rather than doing the work itself.

Your observation about Signal() selecting the first permitted CPU without considering its current load is particularly interesting. With applications that frequently wake workers, such as browsers or rendering systems, I wonder whether that could result in excessive interprocessor signaling, repeated scheduling activity and contention around shared scheduler structures.

That might explain why adding processors does not necessarily produce a corresponding increase in useful throughput.

During the past couple of weeks, I have made several patches to the x86_64 SMP kernel, concentrating on task-state transitions, locking, scheduler interactions and interrupt handling. Some corrections have improved execution, but I am still investigating intermittent freezes.

I haven't yet established whether those changes affect the specific Signal() wake-up path you identified, nor have I measured the scheduling latency directly.

I think the important measurement is not simply how busy each CPU is, but how much of that time is spent executing useful application code versus scheduler activity, synchronization, interrupts and waiting for locks.

This is also an area where AROSA's resource monitoring and capability architecture could be useful. I want to extend AResourceMonitor to show CPU and memory consumption by application, task, service and composition, with enough kernel instrumentation to distinguish productive execution from scheduling overhead.

Your proposed wake-up latency measurement would complement that work very well.

I would be interested in comparing the results of your local scheduler change with the behavior I'm observing. It might help establish whether we are looking at related problems or two different limitations in the SMP implementation.

Ultimately, the objective is not just to have several CPUs active, but to have them executing useful work efficiently while keeping the overall system responsive.
D
danilosJunior Member
Posted 5 hours ago

Bohun wrote:

@Bohun - Please explain to a layman what AROSA is? Is it a program that distributes the threads of a single-core application across multiple cores?


Thanks for asking. It's a fair question, because AROSA is considerably broader than a desktop environment or a collection of applications.

AROSA (Application Runtime Operating Services Abstraction) is a service-based application platform built on AROS.

The ambition is to continue and revive the original Amiga vision: an efficient, responsive, innovative and extensible computing environment, while bringing the platform into the 21st century.

Not simply preserving the Amiga experience, but evolving it.

AROS provides the operating-system foundation. AROSA builds on it with a common architecture of services, capabilities, providers, adapters and application composition.

The fundamental idea is that functionality should be reusable across the entire platform, rather than being implemented separately inside every application.

For example, an HTML rendering engine should not belong exclusively to a browser. A graphics engine should not belong exclusively to a drawing program. Search, cryptography, networking, content management, editing and application controls should all be available as reusable platform capabilities.

This is the basis of AROSA's capability consumer/provider architecture.

A service, library or application can request capabilities from the platform, but it can also contribute new capabilities that become available to other components.

Providers supply the implementations. Adapters connect existing libraries, technologies and alternative implementations. Capability contracts define how functionality is accessed, while composition brings the required capabilities together.

This makes it possible to extend the platform without requiring every application to understand the internal implementation of every service.

What does AROSA already contain?

There is already a growing range of implemented and partially integrated capabilities, including:

[list]
[*]Native user-interface framework: Common application windows, controls, reusable components, toolbars, menus, tabbed interfaces, listviews, treeviews, dialogs, configuration surfaces, themes, desktop personalities and shared presentation mechanisms.

[*]Editing and document components: Reusable text editing, code-oriented editing facilities, search, navigation, document presentation and HTML-based help interfaces. These are platform components rather than features tied to a single editor.

[*]Graphics and composition: Canvas drawing, vector graphics, animation, scene composition, transformations, layers, blending, procedural graphics and reusable rendering capabilities.

[*]Fractal generation and ray tracing: Fractal generation and analytic ray-rendering capabilities, with support for combining rendering technologies through composition. Work also includes integration with external scene and parameter formats such as POV-Ray and Fractint.

[*]Web technologies: HTML and CSS processing, JavaScript execution and integration with QuickJS, plus networking, document navigation, media and canvas-related functionality. These technologies are intended to serve applications beyond ABrowser.

[*]Vector and graphics libraries: Integration and adaptation of technologies such as ThorVG, NanoSVG, FreeType and other existing libraries behind reusable platform interfaces.

[*]Cryptography and secure communications: Cryptographic primitives, secure networking, TLS-related capabilities and infrastructure for protecting credentials and application data.

[*]Diagnostics and observability: Centralized logging, tracing, application diagnostics, performance measurements, resource monitoring, system stability probes and historical telemetry.

[*]Foundation and application services: Shared service registration, configuration, state management, application lifecycle, invocation, process execution, dependency handling and resource management.

[*]Identity, sessions and authorization: Users, groups, roles, process security contexts, session management, access-control services and mechanisms for controlling access to applications and resources.

[*]Content and repository services: Content repositories, metadata, versioning, search, permissions, content relationships and SQLite-backed persistence.

[*]Networking and communication: Network services, HTTP-related facilities, transfers, time synchronization and communication providers.

[*]Development and engineering: Application templates, reusable components, descriptors, capability registration and integration with AIDEa, the application engineering environment.
[/list]

These capabilities are not all at the same maturity level. Some are already operating in applications, some have implemented service contracts and providers but require further integration, and others are still being extended.

There is also a wider range of services in the architecture that are under development or planned.

The broader platform architecture

[list]
[*]Session and workspace management: Multiple users and sessions, controlled application ownership, persistent workspaces and independent user environments.

[*]Vault and security services: Encrypted secret storage, key management, credential protection, authorization policies and controlled recovery.

[*]Governance: Policies for identities, services, applications, resources, capabilities, configuration and auditing.

[*]Content management: Shared repositories with versioning, metadata, indexing, search, access policies and extensible content models.

[*]Workflow and automation: Coordinating applications, services, data and operations through reusable workflow capabilities.

[*]Isolation and virtualization: Protected execution environments, resource isolation and eventually compatibility environments for legacy Amiga and AROS software.

[*]Package management and distribution: Installation, capability discovery, dependency resolution, application registration, repositories and reusable deployment descriptors.
[/list]

Applications are both consumers and providers

ABrowser, AFileManager and ACanvasComposer are examples of applications built around this architecture, alongside administrative and monitoring applications.

However, the important point is not the number of applications.

An application can consume capabilities and, where appropriate, provide functionality that other applications or services can reuse.

For example, a rendering capability used by ACanvasComposer should also be usable by a presentation application, an animation tool or another graphics program.

An editing component used in one administration application should be available to other applications without being rewritten.

A cryptographic provider can serve networking, vaults, content repositories and other security-sensitive services.

The same principle applies to web technologies, databases, search, media processing, diagnostics and virtually every other shared function.

AIDEa and application engineering

One of the longer-term objectives is to make the platform itself an application engineering environment.

Developers should be able to build applications through conventional programming, through reusable components, or through declarative application descriptions created with AIDEa.

An application can specify the capabilities it requires and the capabilities it offers.

AROSA's composition and resolution mechanisms then connect those requirements with compatible providers.

This means the application is not necessarily tied to one graphics engine, one networking implementation, one database or one execution mechanism.

It also means that integrating a new library or technology can benefit multiple applications rather than only the program that originally introduced it.

The overall vision

I don't see AROSA as another desktop sitting on top of AROS, nor simply as a collection of applications.

It is an attempt to create a coherent application and service platform where operating-system facilities, shared technologies, development tools and applications form one extensible environment.

The Amiga was remarkable because it offered a highly integrated and efficient computing experience on limited hardware.

I believe that philosophy remains valuable, but a modern implementation also needs user and session management, security, shared content, services, graphics, networking, automation, application composition and extensible development capabilities.

The objective is to combine that modern architecture with the efficiency and responsiveness associated with the Amiga tradition.

Every new capability should potentially strengthen the entire ecosystem, not just one application.

That's the direction I'm pursuing with AROSA. It's an independent project built on AROS, with the intention of contributing the results back to the community.
You can view all discussion threads in this forum.
You cannot start a new discussion thread in this forum.
You cannot reply in this discussion thread.
You cannot start on a poll in this forum.
You cannot upload attachments in this forum.
You cannot download attachments in this forum.
Users who participated in discussion: AROS-Confidence, terminills, Bohun, danilos, coffeecat