FAQ SPT

Our application is quite heavy.

Part 1. RAM

Currently it takes up about 1.3 GB of RAM in the computer memory.

99% of this 1.3 GB is taken up by constructing a matrix of prime numbers.
The matrix of prime numbers is made by the code primesieve.
Specific code snippet: https://github.com/kimwalisch/primesieve/tree/2b2c4a5c62f0cd9dfd9f56cca580ea47fa84dc2d
Original sources from Tomash Brada: here
Adaptated by Demis for SPT project: here

The search code itself (in SPT), according to the constructed matrix, takes up only 5-6MB in memory.
And it doesn't increase.

When our project started, the memory size for the matrix of one task was approximately 620MB.
Now 1.3 GB.
And it will slowly increase.
The longer the numbers, the more memory they require in the primesieve matrix.

One of our tasks takes, on average, from 45 minutes to 1.5 hours.
Although we see exceptions to this rule.
There are cruncher computers that count in 20 minutes.
And there are cruncher computers that count in 240 minutes.

In any case, users have questions.

Most often, those who
   and works on a computer,
   and at the same time considers different boinc projects,
   and watches movies...

The main recommendation would be:
1. Reduce the amount of resources allocated to the project.
This can be easily done in the "Computing preferences" section on the page:
https://boinc.termit.me/adsl/prefs
(need login)

When computer is in use
Suspend when non-BOINC CPU usage is above	25 %
Use at most	50 % of memory

When computer is not in use
Suspend when non-BOINC CPU usage is above
Requires BOINC 7.20.3+	25 %
Use at most	90 % of memory

2. Reduce the number of occupied cores in the boinc-manager.
In the main menu of the Options->Computing preferences

Options->Computing preferences->Computing

and Options->Computing preferences->Disk

3. How, approximately, can you independently calculate the settings for your computer?

For example:
I have an x64 computer
   which has 2 cores,
   hyperthreading enabled,
   physical memory 4GB.

2x2 = 4 cores.

1 core must be left free for the OS.
It turns out 4 - 1 = 3 cores can be occupied by SPT calculations (or others projects).

Let's calculate the required memory for the SPT application:
3 x 1.3 = 3.9 GB.
It turns out a lot for 4GB,
since we still have to have resources for the OS and other applications
(boinc or not, it doesn't matter).
There is a high probability that the application will go to a swap file.
This will cause a sharp slowdown.

Therefore, you need to reduce the simultaneous launch of "SPT" by another "one application".
3 - 1 = 2 cores - can be used.

Now you can go to the settings and set the CPU usage to 50% in the boinc-manager.
(100% is 4 cores, 50% is two cores).

In the same way you can calculate
   and for 4-core processors,
   and for 8 core processors,
   and for more multi-core processors.

At the request of crunchers, recommendations for setting up a local boinc-client:

<app_config>
	<project_max_concurrent>8</project_max_concurrent>
</app_config>

Use an app_config file with this inside it. This example will limit the number of tasks running on the project to only 8 tasks at once. Which given the amount of RAM the project currently requires, that'll be 10.4GB of RAM for SPT, which will allow users to run other projects on the CPU Cores/Threads to ensure their CPU and system is fully utilized crunching something.

Replace the "8" in that code snippet with the maximum number of tasks you wish to allow to run based on the amount of system RAM the system may have.

The file goes in the projects directory.

That would be /projects/boinc.termit.me_adsl/ directory inside the BOINC data directory.

Part 2. Time

Dear crunchers, be careful.

Correctly take into account the time required to complete the tasks you take on.

What do we mean?

According to open statistics, we can see that very often there are cases when
one computer with 4 cores takes on 1000 or more tasks for calculation.

Our project has 6 days to receive a response from a cruncher.
(Although the standard is 7 days.)

As it is written in Part 1: "One of our tasks takes, on average, from 45 minutes to 1.5 hours."
Let's assume that one task counts as one hour.

Now we count:
One task - 1 hour
computer - 4 cores.
Loaded tasks - 1000 pieces.
Days to respond - 6 days.

======================
One core will calculate 24 hours per day * 1 core = 24 tasks.
4 cores * 24 tasks = 96 tasks.
For the entire period of 6 days: 6 days * 96 tasks = 576 tasks.
======================

It is clear that the calculated tasks are constantly updated.
You need to understand that not all cores are always used, as described in Part 1.

Thus, the number 576 may actually turn out to be even smaller.

A situation arises: such a computer will never count 1000 - 576 = 424 tasks.
And such tasks will go into the "Timed out - no response" error state in the statistics of such a computer.

For our project this is not a problem.
The server will automatically reassign such tasks to another computer.

Please note that our server practically does not limit the issuance of tasks.

Please - calculate your resources and your time correctly!