JAM_SEMAPHORE test does not seem correct.

[tee3]

Make sure you completed the following tasks

• I searched the discussions
• I searched the closed and open issues
• I read the contribution guidelines

Environment and version details

• Operating System+version: Linux Ubuntu 20.04
• Compiler+version: GCC 9
• Shell: Bash
• B2 Version: Output of b2 -v and b2 --version

$ b2 -v
B2 Version 4.0. OS=LINUX.
  Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
  Copyright 2001 David Turner.
  Copyright 2001-2004 David Abrahams.
  Copyright 2002-2019 Rene Rivera.
  Copyright 2003-2015 Vladimir Prus.

  DEFAULTS: jobs = 8
$ b2 --version
Boost.Build 4.0-git

• B2 Configuration: Output of b2 --debug-configuration in your project.

N/A

Brief problem description

The test for JAM_SEMAPHORE in core_multifile_actions.py does not seem to actually test the semaphore.

Steps to reproduce the issue

I removed the JAM_SEMAPHORE in the test and it still passed. I would hope that the test would fail if the semaphore was not set properly.

Looking at the code, there is only one action happening in the test, so there is no chance for anything to run in parallel.

actions update
{
    echo updating $(<)
}

targets = x1 x2 ;
JAM_SEMAPHORE on $(targets) = <s>update_sem ;
update x1 x2 ;

The output is expected to be such. The printout updating x1 x2 suggests to me that only one action is running, so I don't see how anything could run in parallel. I added a sleep 60 in the update action and the test only takes 60 seconds, again suggesting that only one action is running.

...found 2 targets...                                                                                                                                                                                                                               
...updating 2 targets...                                                                                                                                                                                                                            
update x1                                                                                                                                                                                                                                           
updating x1 x2                                                                                                                                                                                                                                      
...updated 2 targets...                                                                                                                                                                                                                             

Actual behavior summary

The targets update in the same order whether the JAM_SEMAPHORE is set or not.

Expected behavior summary

I would expect the test to fail if the semaphore was not set. I attempted to improve the test to actually update the targets in parallel, but I think it requires more work than just a minor change. I tried adding a sleep to the update action there, but

[paolopas]

@tee3, You're right, the test has a bug, but that's it, everything else works (I tried with latest b2 5.5.0).

The problem is that, as the name of the test suggests, core_multifile_actions.py tests actions with more than one file, which in your test is represented by the line

update x1 x2 ;

which calls the update action passing it 2 targets.
To understand why only one of the targets is updated, you need to use at least debug level 4, that is (reducing the example to the bare minimum file.jam):

actions update
{
    echo updating $(<)
}
update x1 x2 ;

you need to use b2 -d4 -f file.jam x1 to see the following results

make	--	x1
make	--	x1
time	--	x1: missing
make	--	 x2
make	--	 x2
time	--	 x2: missing
made+	missing	 x2
made+	missing	x1
...found 2 targets...
...updating 2 targets...
Delaying update x1: 1 targets not ready
Using shell: /bin/sh -c
    argv[0] = '/bin/sh'
    argv[1] = '-c'
    argv[2] = '
    echo updating x1 x2
'
update x1

    echo updating x1 x2

updating x1 x2
0.003877 sec system; 0.004847 sec user; 0.009073 sec clock

...updated 2 targets...

where the line

Delaying update x1: 1 targets not ready

States that target x1 is not actually updated because b2 realizes that the parent command (i.e. the multifile update x1 x2 ;) also depends on x2, which has not been updated yet and therefore x1 must wait. The update x1 line is misleading, but in fact x1 does not build.
This test only builds x2 and is therefore not suitable for testing semaphores (JAM_SEMAPHORE.)

To write a test that attempts to build x1 and x2 at the same time, you need to split the line

update x1 x2 ;

into

update x1 ;
update x2 ;

and that means you are no longer in the context of a multifile action.

@grafikrobot, we need to remove the part that would like to test JAM_SEMAPHORE from this test.

I tested JAM_SEMAPHORE and it works perfectly too. Perhaps writing a test about semaphores might require a cross-platform sleep, I have to think about it.