Lightcone

[mvr]

I've been working on a new catalyst-placing searcher, available here: https://github.com/mvr/lightcone

I haven't run all that many large-scale searches with it yet, but I expect it will be able to find a handful of new elementary conduits.

It's currently missing symmetry support, so using it to find new oscillators is a bit limited.

[mvr]

Some notes on how it works:

Brute Force and Just-in-time

To search for conduits, an obvious method is to simply test each possible arrangement of catalysts and check whether all the catalysts recover. This is the approach taken by the original version of CatForce by Michael Simkin, hence the name.

Original CatForce does cut down on the search space slightly by first calculating the reaction envelope of the input pattern and making sure that at least one catalyst lies in that envelope. After that, though, all possible placements for the other catalysts are tried (within user-specified bounds). This is the case even if the other catalysts do not interact with the pattern at all! Original CatForce applies most of its filtering after a candidate configuration has already been run all the way through.

For a small number of catalysts, say 1 to 3, this strategy can run to completion in a reasonable amount of time. And if many of the catalysts are expected to be transparent the brute force approach is not too wasteful, because the configurations have to be run to completion to determine whether these transparent catalysts recover (although testing non-interacting catalyst placements is still pointless). One spectacular example is this Herschel-to-MWSS partial found by Tanner Jacobi.

Code: Select all

x = 32, y = 32, rule = LifeHistory
20.B3D2B$19.BD2BDB$20.3BD2B$19.D3BDB$20.3BD2B$19.BDBD2B$20.6B$19.6B$
20.6B$19.6B$20.6B$12.B6.6B$11.3B6.6B$9.6B4.7B$3.4B2.7B3.8B$.27B$B2A
26B$3AB2A21BD2B$B2AB3AB2E16BDBD2B$3AB2A2B2E16BDBD2B$2A25BD4B$5.26B$7.
B2.20B$10.19B$10.17B$10.18B$11.5B.11B$11.4B2.12B$18.4B.2BE3B$23.BEBE
2B$24.2E2B$26.B!

For searches involving non-transparent catalysts we can do much better. CatForce treats the first catalyst specially to ensure that it will interact with the active region. But we can generalise that idea to every subsequent catalyst placement too: rather than trying every placement just in case, throughout the search we watch the active pattern evolve and only try catalyst placements that will interact with it in the next generation. It is also easy to track the history of the pattern, and avoid any placement that would have interacted on some earlier generation. This just-in-time placement is used by all the other search tools I am aware of, including my "Symmetric" fork of CatForce.

On its own this is a huge improvement, because the reaction envelope can vary a lot after just a single catalyst placement.

Code: Select all

x = 62, y = 46, rule = LifeHistory
50.B$45.7B$45.8B$45.9B$45.10B$45.9B$46.8B$43.11B$43.12B3D$42.13BDBD$
41.14BDBDB$40.2B3D11BD2B$40.10B2D7B$39.BD5BDB2D2BD7B$38.2BD5B2DBDBD8B
$38.2BD5BD3BD10B$38.24B$39.2B.3D16B$43.B.3BD10B$46.2BD9B$46.2BD8B$38.
C7.11B$38.3C5.11B$41.C4.12B$12.4B24.2C3.B.11B$11.2D5B22.18B$11.2D5B2D
22.17B$12.6B2D22.13BD4B$11.9B21.14BD5B$9.5BD5B19.16BD4B$7.7BD5B17.23B
$7.2BA4BD3B.B2C15.2BA19B$6.3BABA4B3.BC.C13.3BABA7BD8B$7.2B3A4B6.C14.
2B3A7BD7B$6.5BA4B6.2C12.5BA7BD7B$5.10B20.10B2.8B$4.4B26.4B10.7B$3.4B
26.4B12.6B$2.4B26.4B12.7B$.4B26.4B14.6B$4B26.4B14.6B$3B26.4B15.7B$2B
26.4B16.6B$B26.4B18.4B$26.4B19.4B$25.4B21.2B!

The overall structure of the search is then a depth-first search over catalyst positions. At each node of the search tree, we either place a catalyst which interacts on the current generation, or advance to the next generation.


Contacts and Approaches

The first new idea, which functions independently of the others, is to only try placements where the active pattern is in the right shape for the catalysis to succeed. Let us consider the ordinary eater.

Code: Select all

x = 39, y = 7, rule = LifeHistory
5.A9.2A8.A10.A$5.A.A7.2A8.A9.A.A$4.D2A7.D2A7.DA8.DA2.A$2.2CD7.2CD7.2C
D7.2CD.2A$.C.C7.C.C7.C.C7.C.C$.C9.C9.C9.C$2C8.2C8.2C8.2C!

The vast majority of successful interactions with the head of the eater begin with the birth of exactly those two marked cells, cells that wouldn't otherwise be born if not for the eater. I have been calling such perturbed cells the contact point of the catalyst. These contact points are easy to calculate in a pre-processing step.

If the initial interaction does not match, it is overwhelmingly likely that the catalyst is going to explode rather than recovering, and so knowing the contact points let us cut down the number of placements to check. Looking at the upper contact cell for the eater, a birth is caused when it gains exactly two active neighbours. When iterating through the reaction envelope, we only need to consider offsets for the eater that put that contact cell next to exactly two active cells.

Beyond just checking the contact point, we can look at more of the active pattern. The following (contrived) situation has the correct neighbour counts, but is also overwhelmingly likely to not work because the active pattern has the wrong shape.

Code: Select all

x = 6, y = 6, rule = LifeHistory
3A.A$4.DA$2.2CD$.C.C$.C$2C!

The required shape of active cells I have been calling the approach. In Lightcone I check that the approach is correct by extracting a 5x5 "signature" around each possible contact point in the active pattern, and comparing it to the precomputed 5x5 signature around the contact point in the catalyst. (This is a bit faster than dealing with the entire state.) For the eater, the approach looks like:

Code: Select all

x = 6, y = 6, rule = LifeHistory
2.3DA$2.3DA$2.2C2D$.CDC2D$.C4D$2C!

The cells to the right of those two active ones are unrestricted: there are many possibilities that work. Other catalysts are much more particular about the approach they will interact with.

Code: Select all

x = 14, y = 11, rule = LifeHistory
3.2A$3.A5.DC2D$2A.A5.2D3C$A.2A.2A2.5D$5.A.A.DA3D$5.A.4A3D$6.A6.A$7.A
2.4A$6.2A2.A$11.A$10.2A!

There is a trade-off to this strategy, of course: we are deliberately excluding unusual interactions that begin in some other way. Each individual unusual interaction is not likely to work, but collectively, we might be cutting out a lot of interesting results. Checking approaches really does make a huge difference to performance, so the reader will have to decide whether losing out on these serendipitous results is worth it.


Problems and their Lightcones

If a non-transparent catalyst is destroyed, it is unlikely to reform by chance. For this reason, most search tools allow the user to specify required cells of the catalyst, which are not allowed to have their state flipped at any point. For the eater, this might be all the marked cells in:

Code: Select all

x = 5, y = 6, rule = LifeHistory
2.2D$.2DCA$.DCDC$2DC2D$D2CD$4D!

This includes most of the cells in a halo around the catalyst: if a neighbouring cell on the left side is flipped on, the eater is probably in the process of exploding.

If after advancing the overall state we find that one of these required cells has its state flipped, we can drop that branch of the search: it is safe to assume that the catalyst will never recover.

A required cell failing is an example of what I call a problem that may occur with a given configuration. There are a handful of other problems that Lightcone can currently test for:

• Required cells failing, as above.
• A filter for a particular state failing. For example, you may want to make sure that a glider escapes from a reaction.
• A catalyst failing to recover within a specified time.
• An overall time limit being reached without all catalysts recovered.
• An overall time limit being reached without any catalysts interacting at all
• A catalyst marked "transparent" not actually acting transparently. This is most common with blocks, and is intended to avoid "boring" results.
• A piece of junk surviving for too long.

Any time one of these problems occurs, we can safely drop that branch of the search: there is no way for a problem of one of these kinds to be solvable at any point further into the future.

Here is the next key idea. Rather than waiting until a problem occurs to react to it, at each node of the search tree we can run a lookahead (with no further catalyst placements) to find the next problem that will occur. Once its time and location is known, this is a strong constraint on any possible solution. There must be at least one additional catalyst placement at a time and location that has a chance of averting the problem. That is, there must be at least one catalyst placement that has its contact points within the past lightcone of the problem, and so we can save time by trying to find this catalyst placement first.

For example, consider the following interaction, with the required cells of the eater marked. After 36 generations we encounter a problem: one of the required cells of the eater has flipped.

Code: Select all

x = 46, y = 13, rule = LifeHistory
33.4B$32.A6B$32.2A6B$33.7B$32.10B$30.12B$28.12B2A$A27.12BA2B$A.A8.ACD
13.10B4.A2D$3A7.DC4D12.9B3.DC4D$2.A7.2D3CD11.BA8B3.2D3CD$11.3DCD10.2A
8B5.3DCD$13.3D11.2A14.3D!

Now we rewind back to generation 29, the moment we interacted with the first eater. To have a chance at solving the problem, the next placement must be in the following box.

Code: Select all

x = 23, y = 15, rule = LifeHistory
8.D2C12D$6.2AD3C11D$6.2A3D2C10D$5.3BCDC2DC9D$3.5B3C2D2C8D$.7BCDCD2C9D
$.7B4D3C8D$2BA5B6D2C7D$.A6B6DC8D$.3A4B7D3C5D$2.6B9DC5D$8.15D$8.15D$8.
15D$8.15D!

This doesn't help much right now, but as we advance in time this box gets more and more restrictive. After 2 more generations, we are down to the following region and no longer have to test any placements that interact with the left part of the active pattern; they are too far away to solve the problem.

Code: Select all

x = 21, y = 13, rule = LifeHistory
7.4AB$6.2AB4A$6.AB2AD2C8D$5.3BABDCD2C6D$3.4B2AB2CD2C6D$.6B2ABC10D$.9B
DC9D$10B4D2C5D$.A8B4DC6D$.ABA6B5D3C3D$.2A6B.7DC3D$10.11D$10.11D!

In fact, this is the generation than contains the unique solution to this problem that uses another eater. The following placement is just barely close enough to have an impact: the difference in the evolution of the pattern travels at near lightspeed to reach the problem in time.

Code: Select all

x = 21, y = 14, rule = LifeHistory
18.2A$7.4AB6.A$6.2AB4A3.A.A$6.AB2AD2C2D3C3D$5.3BABDCD3C5D$3.4B2AB2CD
2C6D$.6B2ABC10D$.9BDC9D$10B4D2C5D$.A8B4DC6D$.ABA6B5D3C3D$.2A6B.7DC3D$
10.11D$10.11D!

In general, after solving the one problem there is a good chance we expose a new problem that needs solving. In the following situation, the second eater saves the first one, and in turn in saved by the third one.

Code: Select all

x = 24, y = 22, rule = LifeHistory
7.2A$8.A$8.A.A11.2A$9.2A11.A$20.A.A$20.2A9$A$A.A$3A$2.A$14.2A$14.A$
15.3A$17.A!

This search strategy can cause placements to be tested non-chronologically, because after solving a problem that occurs one part of the state, we may free ourselves to go back and interact with some other part of the state. This non-chronological placement appears to be fairly rare in practice.

Code: Select all

x = 21, y = 21, rule = LifeHistory
12.4D$12.D2CD$13.2A8$A$A.A$3A$2.A2$12.2A3.2D$11.D2CD.AC2D$11.4D.CDCD$
16.2DC2D$17.D2CD$17.4D!

The eater is placed in order to save the lower block, but once that is done, Lightcone is able to rewind and place the upper block.

So much for the past lightcone of a problem. There is another place that we can use lightspeed considerations to our advantage. As it stands, after we place a catalyst, we begin anew and test all locations in the envelope of the active pattern for whether they are suitable for a catalyst placement. But we don't need to throw away all the work we've already done: the new active reaction can only be different from the previous one within the future lightcone of the placement we just made. Outside that lightcone, the determinations we made for whether a placement is valid can be reused.


Bloom Filter

For some perturbations, there are often multiple catalysts that can cause the same perturbation. The eater 1 and eater 2 are notorious examples.

Code: Select all

x = 37, y = 10, rule = LifeHistory
5.A9.2A8.A9.2A$5.A.A7.2A8.A.A7.2A$5.2A8.2A8.2A8.2A$2.2C8.2C6.C.2C6.C.
2C$.C.C7.C.C4.3C.2C4.3C.2C$.C9.C5.C9.C$2C8.2C6.3C.2C4.3C.2C$20.C.C7.C
.C$20.C.C7.C.C$21.C9.C!

Unless this duplication is somehow dealt with, it can cause a combinatorial explosion in the search tree where all combinations of eater 1s and eater 2s are tried even if they lead to the same perturbation.

Code: Select all

x = 83, y = 39, rule = LifeHistory
46.C19.C$45.C.C17.C.C$45.C.C17.C.C$C19.C22.3C.2C14.3C.2C$3C9.C7.3C9.C
9.C14.C4.C14.C$3.C6.3C10.C6.3C10.3C.2C6.3C5.3C.2C6.3C$2.2C5.C12.2C5.C
15.C.2C5.C10.C.2C5.C$9.2C18.2C23.2C18.2C5$.A8.2C9.A8.2C.C12.A8.2C9.A
8.2C.C$.A.A6.C.C8.A.A6.2C.3C10.A.A6.C.C8.A.A6.2C.3C$.3A8.C8.3A12.C9.
3A8.C8.3A12.C$3.A8.2C9.A6.2C.3C12.A8.2C9.A6.2C.3C$31.C.C42.C.C$31.C.C
42.C.C$32.C44.C2$46.C20.C$11.C20.C12.C.C8.C9.C.C8.C$10.C.C18.C.C11.C.
C7.C.C8.C.C7.C.C$C9.C.C8.C9.C.C9.3C.2C6.C.C6.3C.2C6.C.C$3C6.2C.3C6.3C
6.2C.3C6.C11.2C.3C3.C11.2C.3C$3.C11.C8.C11.C6.3C.2C11.C3.3C.2C11.C$2.
2C5.2C.3C8.2C5.2C.3C9.C.2C5.2C.3C6.C.2C5.2C.3C$9.2C.C17.2C.C20.2C.C
17.2C.C5$.A8.2C10.A8.2C.C11.A8.2C10.A8.2C.C$.A.A6.C.C9.A.A6.2C.3C9.A.
A6.C.C9.A.A6.2C.3C$.3A8.C9.3A12.C8.3A8.C9.3A12.C$3.A8.2C10.A6.2C.3C
11.A8.2C10.A6.2C.3C$32.C.C42.C.C$32.C.C42.C.C$33.C44.C!

Here I follow Adam P. Goucher's idea for Silk (unimplemented at time of writing) to use a Bloom filter to quickly test whether the reaction has been seen previously. A Bloom filter lets us store the hash of many millions of states using relatively little memory. The trade-off is a small risk of false positives, once too many hashes have been added to the filter. Again following a suggestion by apg, the filter is reset to empty once the chance of false positives reaches an intolerable level.

The criteria for when the active pattern is tested against the Bloom filter were arrived at through trial and error. Right now, the pattern is tested and added to the filter when

• all non-transparent catalysts are present,
• at least two generations have passed since the most recent catalyst was placed, and
• the population of the active pattern is at least 12.

Of course, there is another balance to be struck here. We want to catch as many repeated reactions as possible, but not accidentally consider some dying sparks as coming from identical if they were actually arrived at by different means.


Future Ideas

Lightcone is certainly not the last word in conduit searching. It's much smarter than a brute force search, but still makes choices that are obviously silly to the human eye. I'd love to hear ideas on any of the following topics:

Catalyst Welding

Lightcone only tries placing complete catalysts, and excludes any placement that will cause two catalysts to interact. This will inevitably miss some solutions that involve non-trivial welds to pack catalysts slightly closer together than otherwise possible. One unsatisfying solution is for the user to provide pre-welded catalyst pairs as input, but in an ideal world Lightcone would do this systematically and automatically.

This will likely mean testing all interacting offsets of one catalyst against another, and testing whether a weld is possible. Presumably a SAT solver could make short work of this.

In a branch, I've had a go at implementing this, but the performance hit is unreasonably high (at least with the method I'm using currently).

Avoiding Hopeless Placements

Currently, some time is spent on placements where the recovery sequence of one catalyst leads to a cascade of interactions with additional catalysts. For example, the following completely hopeless chain of block reactions:

Code: Select all

x = 12, y = 10, rule = LifeHistory
3.2A.3A$5.A$2D8.2D$DCA2.2A2.ACD$DCA.D2CD.ACD$2D2.4D2.2D2$.2A6.2A$D2CD
4.D2CD$4D4.4D!

It would be nice if these could be avoided without hardcoding those nearby block placements to be forbidden. It's unclear to me what the correct heuristic is here. We have to be careful: not all tightly packed catalysts are useless. The similarly close eater in the following example is necessary for the block to survive.

Code: Select all

x = 10, y = 11, rule = LifeHistory
2.2A$A.2A$3A$.A2$.2A3.2D$D2CD.AC2D$4D.CDCD$5.2DC2D$6.D2CD$6.4D!

Beyond Tree Search

Currently, Lightcone always tackles the chronologically earliest problem that occurs with the current configuration. In some situations this leads to poor performance, especially when the active region splits into two fairly separated pieces.

Code: Select all

x = 31, y = 31, rule = LifeHistory
22.2A$17.2A3.A.A2.2A$17.A6.A3.A$9.2A3.2A.A2.4A.3A$9.A4.A.A3.A2.A.A$
10.3A.A8.ABAB3A$12.A.2A2.B3.2B2ABA2.A$13.7B.6B2.2A$15.10B$6.A8.9B$6.
3A6.10B$9.A6.8B$8.2A3.B3.9B$8.8B.9B$10.18B2D$10.18BDBD$9.21BD$7.20BDB
2D$5.22B2D$5.2BC19B$4.3BCBC16B$5.2B3C15B$4.5BC12B.2B$3.10B2.8B$2.4B
10.9B$.4B12.6B.2A$4B12.8B2A$3B14.6B.B$2B15.BDBD$B17.DBD$18.3D!

A problem in the left region may be solved, revealing a problem in the right region, and vice versa. This alternation causes a combinatorial blowup in the time it takes to make progress on either side. In theory it should be possible to choose which problem to focus on more intelligently, but doing so naively causes even bigger issues: Lightcone might go down a rabbithole solving problems on the left, when it might be easy to show that problems on the right are unsolvable.

This may be an opportunity for some parallelism: if there are multiple
problems that are lightcone separated, we could attempt to resolve
them in different threads.

[Katrina]

This program doesn't work because running

Code: Select all

git submodule update --init

uses SSH which isn't supported by my computer

Make is not Windows, and I have to use WSL which can't use SSH

[Scorbie]

Installation using mingw-w64
I checked in both clang64 and ucrt environments. Haven't checked in other environments.

Code: Select all

# install compiler toolchain
pacman -Ss gcc # confirm your package name for gcc
pacman -S mingw-w64-ucrt-x86_64-gcc # use the package name you searched above
pacman -S make
# build
git clone https://github.com/mvr/lightcone.git
cd lightcone
git submodule update --init --recursive
make CXX=g++ LDFLAGS= # default c++ compiler is clang++, so you don't need CXX=clang++ if you're using clang

references
[1] https://stackoverflow.com/questions/554 ... d-option-z

[mvr]

As a satisfying test case, this file re-finds apg's Spartan G-to-W in a couple of seconds: (Of course, it helps when you know where to look...)

Code: Select all

first-active-range = [100, 101]
min-stable-time = 40
max-stationary-time = 50

max-transparent = 1

use-bloom-filter = true

pattern-center = [30, 30]
pattern = """
x = 60, y = 60, rule = LifeHistory
BA58B$2BA57B$3A57B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$
60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$
60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$
60B$60B$60B$60B$60B$60B$60B$60B$60B$60B$60B!
"""

[[catalyst]]
rle = "2o$2o!"
recovery-range = [4, 120]
transparent = true

[[catalyst]]
rle = "2b2o$bobo$bo$2o!"
recovery-range = [ 2, 6,]
required = "2.2D$.2DCA$.DCDC$2DC2D$D2CD$4D!"
approaches = [ "2.3DC$2.3DC$2.2A2D$.ADA2D$.A4D$2A!",]

[LuveelVoom]

What would the configuration file be for trying to find a blockic wing-to- any common region (b, h, etc)?

[mvr]

Here's one that you can tinker with. There isn't a way to ask it to look for conduits directly though.

Code: Select all

first-active-range = [1, 100]
min-stable-time = 10

max-transparent = 1

use-bloom-filter = true

pattern-center = [25, 30]
pattern = """
x = 52, y = 62, rule = LifeHistory
52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$
52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$5.47B$5.47B$.A3.47B$.
2A2.47B$3.A.47B$2.2A.47B$5.47B$5.47B$52B$52B$52B$52B$52B$52B$52B$52B$
52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B$52B!
"""

[[catalyst]]
rle = "2o$2o!"
recovery-range = [ 2, 8,]
required = "4D$D2CD$.2A!"
approaches = [ "2D2A2D$2D2A2D$6D$2DC2D!", "2D2A2D$2D2A2D$6D$.2DC2D!",]
forbidden = [ "2.2A$2.2A$.3D$2DCD$D2C2D$DCDCD$5D!", ".2A$.2A$.3D$2DCD$D2C2D$DCDCD$5D!", "2.2A$2.2A$.3D$.DC2D$2D2CD$DCDCD$5D!", ".2A$.2A$.3D$.DC2D$2D2CD$DCDCD$5D!",]
soup = "4b2o$4b2o5$o4b3o$obo2b3o$3o3bo$o2bob2o$o$b2ob3o$obob2obo$b2o2b2o!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [ 3, 6,]
required = ".2A$D2CD$4D!"
approaches = [ "D$3D2CD$7D$2D2A3D$2D2A3D!",]
summary = "2.2A$2.2A19$2.2A$.D2CD$.4D15$D$3D2CD$7D$2D2A3D$2D2A3D!"
soup = "10b2o2b2o$9bobob2obo$10b2ob3o$9bo$9bo2bob2o$9b3o3bo$9bobo2b3o$9bo4b3o5$2o$2o!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [ 6, 6,]
required = "4D$DAC$.2A!"
approaches = [ "2D2A2D$2D2A2D$6D$2DC3D$D3C2D!",]
summary = "2.2A$2.2A18$.4D$.DAC$2.2A19$2D2A2D$2D2A2D$6D$2DC3D$D3C2D!"
soup = "17b2o$17b2o15$3o3bo$3ob2obo$3o$4bob2o$3o2b2o$2obo2b2o$3bo2bo$bo2b3o!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [ 4, 5,]
required = "2.2D$.ACD$D2CD$4D!"
approaches = [ ".D3CD$6D$3D2AD$3D2AD!",]
summary = "3.2A$3.2A18$4.2D$3.ACD$2.D2CD$2.4D16$.D3CD$6D$3D2AD$3D2AD!"
soup = "o2b4o$3b5o$2obobo$ob4obo$b5o$3o2bo$b2o4bo$5bo3$3b2o$3b2o!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [4, 50]
transparent = true
forbidden = [ ".3D$.DC2D$3DCD$D3CD$5D$4.2A$4.2A!", ".3D$.DC2D$3DCD$D3CD$5D2A$5.2A!", "5.2A$.4D2A$2D2CD$DCDCD$3DCD$2.3D!", "4.2A$4.2A$.4D$2D2CD$DCDCD$3DCD$2.3D!", "2A$2A5D$2.D3CD$2.DC3D$2.2DCD$3.3D!", "2A$2A$.5D$.D3CD$.DC3D$.2DCD$2.3D!", ".3D$.DC3D$.DCDCD$.D2C2D$.4D$2A$2A!", "2.3D$2.DC3D$2.DCDCD$2.D2C2D$2A4D$2A!", "2.3D$.2DCD$.DC3D$.D3CD$.5D$2A$2A!", "3.3D$2.2DCD$2.DC3D$2.D3CD$2A5D$2A!", "5.2A$5D2A$D3CD$3DCD$.DC2D$.3D!", "4.2A$4.2A$5D$D3CD$3DCD$.DC2D$.3D!", "2.3D$3DCD$DCDCD$2D2CD$.4D$4.2A$4.2A!", "2.3D$3DCD$DCDCD$2D2CD$.4D2A$5.2A!", "2A$2A4D$2.D2C2D$2.DCDCD$2.DC3D$2.3D!", "2A$2A$.4D$.D2C2D$.DCDCD$.DC3D$.3D!", "5D$DCDCD$2D2CD$.DC2D$.3D$3.2A$3.2A!", "5D$DCDCD$2D2CD$.DC2D$.3D$2.2A$2.2A!", "5D$DCDCD$2D2CD$.DC2D$.3D$.2A$.2A!", "5D$DCDCD$2D2CD$.DC2D$.3D$2A$2A!", "4D$D2C2D$2D2CD$DC3D2A$3D2.2A!", "4D$D2C2D$2D2CD2A$DC3D2A$3D!", "4D$D2C2D2A$2D2CD2A$DC3D$3D!", "4D.2A$D2C2D2A$2D2CD$DC3D$3D!", "3.2A$3.2A$.3D$2DCD$D2C2D$DCDCD$5D!", "2.2A$2.2A$.3D$2DCD$D2C2D$DCDCD$5D!", ".2A$.2A$.3D$2DCD$D2C2D$DCDCD$5D!", "2A$2A$.3D$2DCD$D2C2D$DCDCD$5D!", "4.3D$2.3DCD$2.D2C2D$2A2D2CD$2A.4D!", "4.3D$2.3DCD$2AD2C2D$2A2D2CD$3.4D!", "4.3D$2A3DCD$2AD2C2D$2.2D2CD$3.4D!", "2A2.3D$2A3DCD$2.D2C2D$2.2D2CD$3.4D!", "5D$DCDCD$D2C2D$2DCD$.3D$3.2A$3.2A!", "5D$DCDCD$D2C2D$2DCD$.3D$2.2A$2.2A!", "5D$DCDCD$D2C2D$2DCD$.3D$.2A$.2A!", "5D$DCDCD$D2C2D$2DCD$.3D$2A$2A!", "3.2A$3.2A$.3D$.DC2D$2D2CD$DCDCD$5D!", "2.2A$2.2A$.3D$.DC2D$2D2CD$DCDCD$5D!", ".2A$.2A$.3D$.DC2D$2D2CD$DCDCD$5D!", "2A$2A$.3D$.DC2D$2D2CD$DCDCD$5D!", "3D$DC3D$2D2CD$D2C2D2A$4D.2A!", "3D$DC3D$2D2CD2A$D2C2D2A$4D!", "3D$DC3D2A$2D2CD2A$D2C2D$4D!", "3D2.2A$DC3D2A$2D2CD$D2C2D$4D!", "3.4D$2.2D2CD$2.D2C2D$2A3DCD$2A2.3D!", "3.4D$2.2D2CD$2AD2C2D$2A3DCD$4.3D!", "3.4D$2A2D2CD$2AD2C2D$2.3DCD$4.3D!", "2A.4D$2A2D2CD$2.D2C2D$2.3DCD$4.3D!",]

[Tawal]

I'm getting errors trying to compile lightcone.

It's OK to clone and update :

Code: Select all

git clone "https://github.com/mvr/lightcone.git"
Clonage dans 'lightcone'...
remote: Enumerating objects: 397, done.
remote: Counting objects: 100% (397/397), done.
remote: Compressing objects: 100% (183/183), done.
remote: Total 397 (delta 253), reused 355 (delta 211), pack-reused 0 (from 0)
Réception d'objets: 100% (397/397), 120.32 Kio | 692.00 Kio/s, fait.
Résolution des deltas: 100% (253/253), fait.

cd lightcone
git submodule update --init --recursive
Sous-module 'LifeAPI' (https://github.com/mvr/LifeAPI.git) enregistré pour le chemin 'LifeAPI'
Sous-module 'toml11' (https://github.com/ToruNiina/toml11.git) enregistré pour le chemin 'toml'
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/LifeAPI'...
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/toml'...
Chemin de sous-module 'LifeAPI' : 'de8188f515ce9cce979eb4f2272a9a759a019632' extrait
Sous-module 'xxHash' (https://github.com/Cyan4973/xxHash.git) enregistré pour le chemin 'LifeAPI/xxHash'
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/LifeAPI/xxHash'...
Chemin de sous-module 'LifeAPI/xxHash' : 'dbea33e47e7c0fe0b7c8592cd931c7430c1f130d' extrait
Chemin de sous-module 'toml' : 'cc0bee4fd46ea1f5db147d63ea545208cc9e8405' extrait
Sous-module 'docs/themes/hugo-book' (https://github.com/alex-shpak/hugo-book.git) enregistré pour le chemin 'toml/docs/themes/hugo-book'
Sous-module 'tests/extlib/doctest' (https://github.com/doctest/doctest.git) enregistré pour le chemin 'toml/tests/extlib/doctest'
Sous-module 'tests/extlib/json' (https://github.com/nlohmann/json.git) enregistré pour le chemin 'toml/tests/extlib/json'
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/toml/docs/themes/hugo-book'...
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/toml/tests/extlib/doctest'...
Clonage dans '/home/tawal/Progs_Externs/GOL/lightcone/toml/tests/extlib/json'...
Chemin de sous-module 'toml/docs/themes/hugo-book' : '7c26d9b8b731d556a2bf89848f59e8300eabc44b' extrait
Chemin de sous-module 'toml/tests/extlib/doctest' : 'ae7a13539fb71f270b87eb2e874fbac80bc8dda2' extrait
Chemin de sous-module 'toml/tests/extlib/json' : '8c391e04fe4195d8be862c97f38cfe10e2a3472e' extrait

But the compilation fails :

Code: Select all

make
clang++ -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -Itoml/include -o LightCone LightCone.cpp -Wl,-stack_size -Wl,0x1000000
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:29:
toml/include/toml11/compat.hpp:433:30: error: no type named 'source_location' in namespace 'std'
using source_location = std::source_location;
                        ~~~~~^
toml/include/toml11/compat.hpp:435:36: error: unknown type name 'source_location'
inline std::string to_string(const source_location& loc)
                                   ^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:30:
In file included from toml/include/toml11/context.hpp:4:
In file included from toml/include/toml11/error_info.hpp:4:
In file included from toml/include/toml11/fwd/error_info_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../source_location.hpp:4:
In file included from toml/include/toml11/fwd/source_location_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../region.hpp:4:
In file included from toml/include/toml11/fwd/region_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../location.hpp:4:
In file included from toml/include/toml11/fwd/location_fwd.hpp:4:
toml/include/toml11/fwd/../result.hpp:363:29: error: no type named 'source_location' in namespace 'toml::cxx'
    value_type& unwrap(cxx::source_location loc = cxx::source_location::current())
                       ~~~~~^
toml/include/toml11/fwd/../result.hpp:371:35: error: no type named 'source_location' in namespace 'toml::cxx'
    value_type const& unwrap(cxx::source_location loc = cxx::source_location::current()) const
                             ~~~~~^
toml/include/toml11/fwd/../result.hpp:391:33: error: no type named 'source_location' in namespace 'toml::cxx'
    error_type& unwrap_err(cxx::source_location loc = cxx::source_location::current())
                           ~~~~~^
toml/include/toml11/fwd/../result.hpp:399:39: error: no type named 'source_location' in namespace 'toml::cxx'
    error_type const& unwrap_err(cxx::source_location loc = cxx::source_location::current()) const
                                 ~~~~~^
toml/include/toml11/fwd/../result.hpp:363:56: error: no member named 'source_location' in namespace 'toml::cxx'
    value_type& unwrap(cxx::source_location loc = cxx::source_location::current())
                                                  ~~~~~^
toml/include/toml11/fwd/../result.hpp:371:62: error: no member named 'source_location' in namespace 'toml::cxx'
    value_type const& unwrap(cxx::source_location loc = cxx::source_location::current()) const
                                                        ~~~~~^
toml/include/toml11/fwd/../result.hpp:391:60: error: no member named 'source_location' in namespace 'toml::cxx'
    error_type& unwrap_err(cxx::source_location loc = cxx::source_location::current())
                                                      ~~~~~^
toml/include/toml11/fwd/../result.hpp:399:66: error: no member named 'source_location' in namespace 'toml::cxx'
    error_type const& unwrap_err(cxx::source_location loc = cxx::source_location::current()) const
                                                            ~~~~~^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:30:
In file included from toml/include/toml11/context.hpp:4:
In file included from toml/include/toml11/error_info.hpp:4:
In file included from toml/include/toml11/fwd/error_info_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../source_location.hpp:4:
In file included from toml/include/toml11/fwd/source_location_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../region.hpp:4:
In file included from toml/include/toml11/fwd/region_fwd.hpp:4:
In file included from toml/include/toml11/fwd/../location.hpp:7:
toml/include/toml11/impl/location_impl.hpp:193:12: error: no matching function for call to 'find_if'
    return find_if(first, last, [val](const location::char_type c) {
           ^~~~~~~
toml/include/toml11/impl/../fwd/location_fwd.hpp:95:1: note: candidate template ignored: substitution failure [with F = (lambda at toml/include/toml11/impl/location_impl.hpp:193:33)]
find_if(const location& first, const location& last, const F& func) noexcept
^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
In file included from toml/include/toml11/impl/literal_impl.hpp:5:
toml/include/toml11/impl/../parser.hpp:3604:15: error: no type named 'source_location' in namespace 'toml::cxx'; did you mean simply 'source_location'?
              cxx::source_location loc = cxx::source_location::current())
              ^~~~~~~~~~~~~~~~~~~~
              source_location
toml/include/toml11/impl/../fwd/source_location_fwd.hpp:14:8: note: 'source_location' declared here
struct source_location
       ^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
In file included from toml/include/toml11/impl/literal_impl.hpp:5:
toml/include/toml11/impl/../parser.hpp:3604:42: error: no member named 'source_location' in namespace 'toml::cxx'; did you mean simply 'source_location'?
              cxx::source_location loc = cxx::source_location::current())
                                         ^~~~~~~~~~~~~~~~~~~~
                                         source_location
toml/include/toml11/impl/../fwd/source_location_fwd.hpp:14:8: note: 'source_location' declared here
struct source_location
       ^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
In file included from toml/include/toml11/impl/literal_impl.hpp:5:
toml/include/toml11/impl/../parser.hpp:3604:64: error: no member named 'current' in 'toml::source_location'
              cxx::source_location loc = cxx::source_location::current())
                                              ~~~~~~~~~~~~~~~~~^
toml/include/toml11/impl/../parser.hpp:3613:9: error: no type named 'source_location' in namespace 'toml::cxx'; did you mean simply 'source_location'?
        cxx::source_location loc = cxx::source_location::current())
        ^~~~~~~~~~~~~~~~~~~~
        source_location
toml/include/toml11/impl/../fwd/source_location_fwd.hpp:14:8: note: 'source_location' declared here
struct source_location
       ^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
In file included from toml/include/toml11/impl/literal_impl.hpp:5:
toml/include/toml11/impl/../parser.hpp:3613:36: error: no member named 'source_location' in namespace 'toml::cxx'; did you mean simply 'source_location'?
        cxx::source_location loc = cxx::source_location::current())
                                   ^~~~~~~~~~~~~~~~~~~~
                                   source_location
toml/include/toml11/impl/../fwd/source_location_fwd.hpp:14:8: note: 'source_location' declared here
struct source_location
       ^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
In file included from toml/include/toml11/impl/literal_impl.hpp:5:
toml/include/toml11/impl/../parser.hpp:3613:58: error: no member named 'current' in 'toml::source_location'
        cxx::source_location loc = cxx::source_location::current())
                                        ~~~~~~~~~~~~~~~~~^
In file included from LightCone.cpp:10:
In file included from ./Params.hpp:5:
In file included from toml/include/toml.hpp:40:
In file included from toml/include/toml11/literal.hpp:7:
toml/include/toml11/impl/literal_impl.hpp:71:28: error: no matching function for call to 'parse_comment_line'
            auto com_res = parse_comment_line(loc, ctx);
                           ^~~~~~~~~~~~~~~~~~
toml/include/toml11/impl/../parser.hpp:101:1: note: candidate template ignored: substitution failure [with TC = toml::type_config]
parse_comment_line(location& loc, context<TC>& ctx)
^
In file included from LightCone.cpp:10:
./Params.hpp:164:23: error: no matching function for call to 'find_or'
  params.outputFile = toml::find_or(toml, "output-file", "lightcone-output.rle");
                      ^~~~~~~~~~~~~
toml/include/toml11/find.hpp:202:1: note: candidate template ignored: could not match 'basic_value<TC>' against 'const char[21]'
find_or(basic_value<TC>& v, const K& k, basic_value<TC>& opt) noexcept
^
toml/include/toml11/find.hpp:215:1: note: candidate template ignored: could not match 'const basic_value<TC>' against 'const char[21]'
find_or(const basic_value<TC>& v, const K& k, const basic_value<TC>& opt) noexcept
^
toml/include/toml11/find.hpp:228:1: note: candidate template ignored: could not match 'basic_value<TC>' against 'const char[21]'
find_or(basic_value<TC>&& v, const K& k, basic_value<TC>&& opt) noexcept
^
toml/include/toml11/find.hpp:246:1: note: candidate template ignored: requirement 'detail::is_exact_toml_type<char[21], toml::basic_value<toml::type_config>>::value' was not satisfied [with T = char[21], TC = toml::type_config, K = char[12]]
find_or(const basic_value<TC>& v, const K& k, const T& opt)
^
toml/include/toml11/find.hpp:263:1: note: candidate template ignored: requirement 'cxx::conjunction<std::negation<std::is_const<const char[21]>>, toml::detail::is_exact_toml_type<const char[21], toml::basic_value<toml::type_config>>>::value' was not satisfied [with T = const char[21], TC = toml::type_config, K = char[12]]
find_or(basic_value<TC>& v, const K& k, T& opt)
^
toml/include/toml11/find.hpp:278:1: note: candidate template ignored: requirement 'detail::is_exact_toml_type<const char *, toml::basic_value<toml::type_config>>::value' was not satisfied [with T = const char *, TC = toml::type_config, K = char[12]]
find_or(basic_value<TC>&& v, const K& k, T opt)
^
toml/include/toml11/find.hpp:297:1: note: candidate template ignored: requirement 'detail::conjunction<std::integral_constant<bool, true>, std::integral_constant<bool, true>, std::integral_constant<bool, true>, std::integral_constant<bool, true>, std::integral_constant<bool, true>, std::integral_constant<bool, true>, std::integral_constant<bool, false>, std::integral_constant<bool, true>>::value' was not satisfied [with TC = toml::type_config, K = char[12]]
find_or(const basic_value<TC>& v, const K& k, const char* opt)
^
toml/include/toml11/find.hpp:319:1: note: candidate template ignored: requirement 'cxx::conjunction<std::negation<toml::detail::is_basic_value_impl<const char *>>, toml::detail::is_not_toml_type<const char *, toml::basic_value<toml::type_config>>, std::negation<std::is_same<const char *, const char *>>>::value' was not satisfied [with T = const char *, TC = toml::type_config, K = char[12]]
find_or(const basic_value<TC>& v, const K& ky, T opt)
^
toml/include/toml11/find.hpp:347:6: note: candidate function template not viable: requires at least 4 arguments, but 3 were provided
auto find_or(Value&& v, const K1& k1, const K2& k2, K3&& k3, Ks&& ... keys) noexcept
     ^
toml/include/toml11/find.hpp:364:3: note: candidate function template not viable: requires at least 4 arguments, but 3 were provided
T find_or(const basic_value<TC>& v, const K1& k1, const K2& k2, const K3& k3, const Ks& ... keys) noexcept
  ^
LightCone.cpp:403:55: warning: unused parameter 'params' [-Wunused-parameter]
void Configuration::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                      ^
LightCone.cpp:509:51: warning: unused parameter 'params' [-Wunused-parameter]
void Lookahead::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                  ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
2 warnings and 20 errors generated.
make: *** [Makefile:15 : LightCone] Erreur 1

Am I doing something wrong ?
How can I correct these errors ?
Thanks.

[mvr]

What version of clang do you have? You might need to update it.

[Tawal]

I'm using clang-14.
Here is the related installed packages :

Code: Select all

dpkg -l | grep clang
ii  clang                                  1:14.0-55.7~deb12u1                  amd64        C, C++ and Objective-C compiler (LLVM based), clang binary
ii  clang-14                               1:14.0.6-12                          amd64        C, C++ and Objective-C compiler
ii  clang-14-doc                           1:14.0.6-12                          all          C, C++ and Objective-C compiler - Documentation
ii  libclang-common-14-dev                 1:14.0.6-12                          all          Clang library - Common development package
ii  libclang-cpp13                         1:13.0.1-11+b2                       amd64        C++ interface to the Clang library
ii  libclang-cpp13-dev                     1:13.0.1-11+b2                       amd64        C++ interface to the Clang library
ii  libclang-cpp14                         1:14.0.6-12                          amd64        C++ interface to the Clang library
ii  libclang-rt-14-dev:amd64               1:14.0.6-12                          amd64        Compiler-rt - development package
ii  libclang1-14                           1:14.0.6-12                          amd64        C interface to the Clang library

Does lightcone need a higher version ? In this case, what is the minimal version number ?
Thanks.

[mvr]

It seems that std::source_location is not fully implemented until clang 15. The toml parsing library I'm using tries to work around this but for some reason that's failing for you. Could you try upgrading clang?

[Tawal]

Thanks for helping me

I'd installed clang-15.
Also, I'd updated the alternatives links :

Code: Select all

sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-15 100
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-15 100

Then try to compile lightcone and get this error now :

Code: Select all

make
clang++ -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -Itoml/include -o LightCone LightCone.cpp -Wl,-stack_size -Wl,0x1000000
LightCone.cpp:403:55: warning: unused parameter 'params' [-Wunused-parameter]
void Configuration::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                      ^
LightCone.cpp:509:51: warning: unused parameter 'params' [-Wunused-parameter]
void Lookahead::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                  ^
LightCone.cpp:728:14: error: no matching constructor for initialization of 'LookaheadOutcome'
      return LookaheadOutcome(problem, bloomSeenGen, timeoutGen, winnerGen, winner);
             ^                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
LightCone.cpp:471:8: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 5 were provided
struct LookaheadOutcome {
       ^
LightCone.cpp:471:8: note: candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 5 were provided
LightCone.cpp:471:8: note: candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 5 were provided
LightCone.cpp:775:69: warning: unused parameter 'search' [-Wunused-parameter]
PlacementValidity TestPlacement(const SearchData &data, SearchNode &search,
                                                                    ^
3 warnings and 1 error generated.
make: *** [Makefile:15 : LightCone] Erreur 1

[mvr]

Could you try replacing the relevant line

Code: Select all

      return LookaheadOutcome(problem, bloomSeenGen, timeoutGen, winnerGen, winner);

with just

Code: Select all

      return {problem, bloomSeenGen, timeoutGen, winnerGen, winner};

and tell me if that works?

[Tawal]

Ok, I've made the replacement.
And get this new error now :

Code: Select all

make
clang++ -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -Itoml/include -o LightCone LightCone.cpp -Wl,-stack_size -Wl,0x1000000
LightCone.cpp:403:55: warning: unused parameter 'params' [-Wunused-parameter]
void Configuration::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                      ^
LightCone.cpp:509:51: warning: unused parameter 'params' [-Wunused-parameter]
void Lookahead::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                  ^
LightCone.cpp:775:69: warning: unused parameter 'search' [-Wunused-parameter]
PlacementValidity TestPlacement(const SearchData &data, SearchNode &search,
                                                                    ^
LightCone.cpp:17:12: warning: variable 'debug_bloom_pattern' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_pattern = "";
           ^
LightCone.cpp:18:12: warning: variable 'debug_bloom_key' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_key = "";
           ^
5 warnings generated.
/usr/bin/ld : avertissement : le groupement des options courtes de la ligne de commande est obsolète : -stack_size
/usr/bin/ld : Erreur : incapable de résoudre les ambigüités : -stack_size (voulez-vous dire --stack_size ?)
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [Makefile:15 : LightCone] Erreur 1

Edit:
Here is my gcc version :

Code: Select all

gcc --version
gcc (Debian 12.2.0-14) 12.2.0
Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

[mvr]

Now you'll have to change the Makefile and delete the line

Code: Select all

LDFLAGS = -Wl,-stack_size -Wl,0x1000000

[Tawal]

Now you'll have to change the Makefile and delete the line

Code: Select all

LDFLAGS = -Wl,-stack_size -Wl,0x1000000

Until you answer, I've made some searches.
And try :

Code: Select all

LDFLAGS = -Wl,-zsatck_size=0x1000000

The option was ignored.

By deleting the 'LDFLAGS = …' line as you tell, I get exactly the same error as my last attempt shown above :

Code: Select all

make
clang++ -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -Itoml/include -o LightCone LightCone.cpp 
LightCone.cpp:403:55: warning: unused parameter 'params' [-Wunused-parameter]
void Configuration::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                      ^
LightCone.cpp:509:51: warning: unused parameter 'params' [-Wunused-parameter]
void Lookahead::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                  ^
LightCone.cpp:775:69: warning: unused parameter 'search' [-Wunused-parameter]
PlacementValidity TestPlacement(const SearchData &data, SearchNode &search,
                                                                    ^
LightCone.cpp:17:12: warning: variable 'debug_bloom_pattern' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_pattern = "";
           ^
LightCone.cpp:18:12: warning: variable 'debug_bloom_key' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_key = "";
           ^
5 warnings generated.
/usr/bin/ld: /tmp/lto-llvm-ec9b57.o: attention: réadressage sur « _ZNSt12out_of_rangeD1Ev@@GLIBCXX_3.4 » dans la section en lecture seule « .text._ZN4toml12format_errorB5cxx11ERKNS_10error_infoE[_ZN4toml12format_errorB5cxx11ERKNS_10error_infoE] »
/usr/bin/ld: /tmp/lto-llvm-ec9b57.o: réadressage R_X86_64_PC32 vers symbole « _ZNSt8ios_base4InitD1Ev@@GLIBCXX_3.4 » ne peut pas être utilisé en créant un objet PIE; recompilez avec -fPIE
/usr/bin/ld : échec de l'édition de liens finale : mauvaise valeur
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [Makefile:15 : LightCone] Erreur 1

So now, I try to add -fPIE option in the CXXFLAGS line :

Code: Select all

CXXFLAGS = -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -fPIE

Then compile :

Code: Select all

make
clang++ -std=c++20 -Wall -Wextra -pedantic -O3 -DNDEBUG -march=native -mtune=native -flto -fno-stack-protector -fomit-frame-pointer -fno-pic -fPIE -Itoml/include -o LightCone LightCone.cpp 
LightCone.cpp:403:55: warning: unused parameter 'params' [-Wunused-parameter]
void Configuration::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                      ^
LightCone.cpp:509:51: warning: unused parameter 'params' [-Wunused-parameter]
void Lookahead::MakePlacement(const SearchParams &params, const CatalystData &catalyst,
                                                  ^
LightCone.cpp:775:69: warning: unused parameter 'search' [-Wunused-parameter]
PlacementValidity TestPlacement(const SearchData &data, SearchNode &search,
                                                                    ^
LightCone.cpp:17:12: warning: variable 'debug_bloom_pattern' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_pattern = "";
           ^
LightCone.cpp:18:12: warning: variable 'debug_bloom_key' is not needed and will not be emitted [-Wunneeded-internal-declaration]
const auto debug_bloom_key = "";
           ^
5 warnings generated.

Except the warnings it seems to work fine
Now I have to test it with an example …

Thanks a lot.


Edit:
I'm glad I managed to compile lightcone with your advice.
But I'll try it later as I've already got some research going on.
I'll be back to tell you how it goes.


Edit2:
Great it works fine
I've launched this command line from the lightcone directory :

Code: Select all

./LightCone tests/minimal.toml

and get this output :

Code: Select all

Winner: 28$32b2o$32b2o3$32b3o$28b2o2bobo2b2o$28b2o2bobo2b2o!
Winner: 28$33b2o$33b2o3$32b3o$28b2o2bobo2b2o$28b2o2bobo2b2o!
Winner: 28$32b2o$32b2o3$32b3o$28b2o2bobo$28b2o2bobo!
Winner: 27$32b2o$32b2o5b2o$39bo$37bobo$37b2o$32b3o$28b2o2bobo$28b2o2bobo!
Winner: 26$38bo$36b3o$35bo$35b2o3$32b3o$28b2o2bobo$28b2o2bobo!
Winner: 27$32b2o$32b2o4$32b3o$28b2o2bobo$28b2o2bobo!
…

beaucoup. (Thank you very much)

[Tawal]

Apologies for double posting
But I think as my matter is solved that the discussion around is closed.

I've made a bash script to create a .rle file with the results (in the directory of the input file).
It outputs that "LightCone is laucnhing" then outputs the number of results found (number of "Winner" lines).
At the end, it outputs the 'Bloom Filter' results.
It creates a rle file with the results vertically arranged and spaced by default by 50 empty lines (this value can be changed on the command line).
(edit: I added an option '-t' to get the Too Long results in another rle file calling Input_Name_Too_Long.rle)
Here is the script :

Code: Select all

#!/usr/bin/bash

###     HERE THE ABSOLUTE PATH TO 'LightCone' EXECUTABLE    ####
LightCone="/home/tawal/Progs_Externs/GOL/lightcone/LightCone"

if [ -f "$1" ]
then
    file_out="${1%.*}.rle"
else
    >&2 echo "Bad file : '$1'"
    exit 1
fi

# Number of vertically empty lines between 2 results.
# You can lanch the script with an affectation of this variable on the command line like this :
#                   Space=80    lightcone.sh    in_file
[ -z "$Space" ] && Space=50
s="$Space$'$'"

too_long_file=""
while getopts :t opt
do
    case sopt in
        t)  too_long_file="${1%.*}_Too_Long.rle"
            echo "x = 0, y = 0, rule = Life" > "$too_long_file"
            ;;
        *) echo "Bad option : '$OPTARG'"
            exit 1
            ;;
    esac
done
shift $((OPTIND-1))

echo "Launching 'LightCone' …"
echo "x = 0, y = 0, rule = Life" > "$file_out"
while read -r l
do
    if [[ "$l" =~ ^Winner:\ (.*)$ ]]
    then
        echo "${BASH_REMATCH[1]%!}$s" >> "$file_out"
        ((n++))
        tput dl1
        echo -n "$n results …"
    elif [ -n "$too_long_file" ] && [[ "$l" =~ ^Too\ Long:\ (.*)$ ]]
    then
        echo "${BASH_REMATCH[1]%!}$s" >> "$too_long_file"
    elif [[ "$l" =~ ^B ]]
    then
        echo -e "\n$l"
    fi
done < <("$LightCone" "$1")

[ "$(wc -l < "$file_out")" -eq 1 ] && rm "$file_out"
[ -f "$too_long_file" ] && [ "$(wc -l < "$too_long_file")" -eq 1 ] && rm "$too_long_file"

Example of return :

Code: Select all

./lightcone.sh    H_to_edgychaos.toml 
Launching 'LightCone' …
20 results …
Bloom filter population: 39

Bloom filter approx    : 39

Bloom filter error rate: 0

Then I have a H_to_edgychaos.rle file in the directory I launched my script.
I just have to open it in Golly to see the results.
The file is "real time" created : I mean as soon as a Winner line appears, the script appends the result in the rle file.
So you can see some results during the execution of the script.


Edit:
I'm looking for adding an option to get the "Too Long" results in another file.
As this will come soon, I'll edit this post …
Done.

Edit:
Corrected an error on regex.

[mvr]

You can also edit LightCone.cpp to get rid of the "Too Long" outputs, I forget the reason I was outputting those in the first place...

[Tawal]

What exactly these 2 parameters do ?

Code: Select all

min-stable-time = 40
max-stationary-time = 40

I tried 80 for each one and got an error that one these values was higher than the hard coded value.

[mvr]

min-stable-time is for how long the catalysts have to sit after reacting before it counts as a solution.

max-stationary-time is the maximum time that any ash is allowed to sit before the configuration is discarded

[Tawal]

I got a matter with the [[filter]] attribute.

On this search pattern :

Code: Select all

x = 20, y = 20, rule = LifeHistory
20B$20B$20B$20B$20B$20B$20B$20B$20B$5.15B$5.15B$3A2.15B$2.A2.15B$3A2.
15B$11.9B2$4.2A$4.A$5.3A$7.A!

I tried this simple in file :

Code: Select all

first-active-range = [0, 50]
min-stable-time = 30
max-catalyst = 3
use-bloom-filter = true

pattern-center = [10, 10]
pattern = """
x = 20, y = 20, rule = LifeHistory
20B$20B$20B$20B$20B$20B$20B$20B$20B$5.15B$5.15B$3A2.15B$2.A2.15B$3A2.
15B$11.9B2$4.2A$4.A$5.3A$7.A!
"""

[[filter]]
rle = "$b2o$bo$2b3o$4bo!"
filter-pos = [14, 26]
filter-gen = 50
filter-type = "EXACT"

[[catalyst]]
rle = "2b2o$bobo$bo$2o!"
recovery-range = [4, 16]
required = "2.2D$.2DCA$.DCDC$2DC2D$D2CD$4D!"
approach = "2.3DC$2.3DC$2.2A2D$.ADA2D$.A4D$2A!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [4, 16]
required = ".2D$ACD$ACD$.2D!"
approach = ".3D$4D$2D2A$CD2A$4D$4D!"

What ever are the values of filter-pos, filter-gen or filter-type, I have the same results/output :

Code: Select all

Winner: 29$22b2o$22b2o3$22b3o2b2o$24bo2b2o$22b3o3$26b2o$26bo$27b3o$29bo!
Winner: 33$22b3o$24bo5b2o$22b3o5b2o3$26b2o$26bo$27b3o$29bo!
Winner: 28$32b2o$32bobo$34bo$34b2o2$22b3o$24bo5b2o$22b3o5b2o3$26b2o$26bo$27b3o$29bo!
Winner: 23$29bo$27b3o$26bo$26b2o7$22b3o$24bo$22b3o3$26b2o$26bo$27b3o$29bo!
Winner: 27$31b2o$31b2o5$22b3o$24bo$22b3o3$26b2o$26bo$27b3o$29bo!
Winner: 23$34bo$32b3o$31bo$31b2o6$32b2o$22b3o7bobo$24bo9bo$22b3o9b2o3$26b2o$26bo$27b3o$29bo!
Winner: 32$31b2o$22b3o6bo$24bo7b3o$22b3o9bo3$26b2o$26bo$27b3o$29bo!
Winner: 28$33b2o$33b2o4$22b3o$24bo$22b3o3$26b2o$26bo$27b3o$29bo!
Winner: 31$33b2o$33bobo$22b3o10bo$24bo10b2o$22b3o3$26b2o$26bo$27b3o$29bo!
Winner: 24$36b2o$36bo$34bobo$34b2o6$22b3o$24bo$22b3o3$26b2o$26bo$27b3o$29bo!
Bloom filter population: 1078
Bloom filter approx    : 1078
Bloom filter error rate: 0

And if you take a look on the 4th result, the bottom Eater1 is destroyed before gen. 50 as shown :

Code: Select all

x = 0, y = 0, rule = B3/S23
23$34bo$32b3o$31bo$31b2o6$32b2o$22b3o7bobo$24bo9bo$22b3o9b2o3$26b2o$26bo$27b3o$29bo!
#C [[ STOP 38 ]]

How to right use this filter ?

[mvr]

Sorry, those [[filter]]s aren't currently implemented. I'll add them in when I have a chance.

[Tawal]

LightCone really needs [[filter]] implementation.
And it has a nasty habit of locking up active regions … which leads to a lot of useless results.

[mvr]

True, that's the downside of having a basically unbounded number of catalysts... They keep getting placed until the active region is completely smothered.

Ok, I've copied over the EVER and EXACT filters, and this file now works:

Code: Select all

first-active-range = [0, 50]
min-stable-time = 30
max-catalyst = 3
use-bloom-filter = true

pattern-center = [10, 10]
pattern = """
x = 20, y = 20, rule = LifeHistory
20B$20B$20B$20B$20B$20B$20B$20B$20B$5.15B$5.15B$3A2.15B$2.A2.15B$3A2.
15B$11.9B2$4.2A$4.A$5.3A$7.A!
"""

[[filter]]
filter = """
x = 4, y = 4, rule = LifeHistory
2C$C$.3C$3.C!
"""
filter-pos = [-6, 6]
filter-gen = 50
filter-type = "EXACT"

[[catalyst]]
rle = "2b2o$bobo$bo$2o!"
recovery-range = [4, 16]
required = "2.2D$.2DCA$.DCDC$2DC2D$D2CD$4D!"
approach = "2.3DC$2.3DC$2.2A2D$.ADA2D$.A4D$2A!"

[[catalyst]]
rle = "2o$2o!"
recovery-range = [4, 16]
required = ".2D$ACD$ACD$.2D!"
approach = ".3D$4D$2D2A$CD2A$4D$4D!"

It would be nice to have MATCH filters, which looks for a pattern occurring anywhere. But I'm not 100% on how they would interact with each other: I guess the most useful thing would be to require all of the EXACT and EVER filters to pass, but just at least one of the MATCH filters to pass.

[Tawal]

Great
I also see that you solved/removed the "Lookahead" matter I've encountered. Thanks.
I still had to remove the LDFLAGS line in the Makefile.
(edit: I had to add -fPIE option in the CXXFLAGS line)

I had these "verbose" lines in the LightCone.cpp :

Code: Select all

int main(int, char *argv[]) {
  if constexpr (print_progress) {
    std::cout << "Loading parameters …" << std::endl;
  }
  
…

    if constexpr (print_progress) {
    std::cout << "Searching …" << std::endl;
  }

  RunSearch(params, data, search, problem);

  if constexpr (print_progress) {
    std::cout << "End of search." << std::endl;
  }

This permits me to get a better handle of the output with my bash script (console output, time stats …)

Edit: Ideas for ameliorations
A real time writing result in a file.
A command line option to split the results file belong a given number (avoiding to have a too big result file).
I have already made this on my bash script

I'm pretty sure you feel when I use DeepL or not