Php forks & shared memory

[Anoniem: 80910]

Mijn vraag
Klopt het dat shmop functies niet werken in een fork ?

Daar kan ik niets over vinden behalve dat het niet werkt en geen exception triggered.

In een ander script gebruik ik het ook en die draait normaliter in de main thread en doet het daar wel.

Tmpfs, een ander snel systeem werkt wel lekker, dus kan er ook voor kiezen om de shmop functie te herschrijven naar een ramdisk functie.

Relevante software en hardware die ik gebruik

Php met name composer package spatie/fork
Mijn eigen custom framework
Shmop functies, heb een class sharedMemory geschreven die een write en een read kan doen en een lijst bijhoud waar wat staat.

Wat ik al gevonden of geprobeerd heb

Heb php.net bezocht, niets over gevonden. Ook op functienaam gegoogled, maar niet in combinatie met een fork. Issues bij de github repository ook niet.

Mijn functie retourneerd false bij een lees of een schrijf actie.

Ik kan zo'n 250 forks tegelijk draaien op mijn laptop met een read op de ramdisk en een conversie van 31 KB json data naar objecten. Zo'n 4 msec per fork. Is er eventueel een manier om van de childprocessen informatie te updaten in de main thread, zodat ik een cache op kan bouwen in de main thread en beschikbaar komt in de fork ?

Ik kan 800 x hetzelfde parsen {{microtime(true}} per seconde, die maakt dan weer gebruik van opcache maar heeft wel 800x een unieke waarden, stel die functie is cacheable, bijvoorbeeld een record, dan wil ik dat graag ervoor zetten, een sharedMemoryObject dan...
...

[ Voor 23% gewijzigd door Anoniem: 80910 op 31-03-2024 23:34 ]

[RobIII]

Het spijt me ontzettend maar ik kan werkelijk geen hout snijden van je topic. Het zijn allemaal losse flarden die weinig met elkaar te maken lijken te hebben of je om/beschrijft 't wel héél abstract. Dit komt een beetje over als een X-Y problem.

Heb je een stuk relevante(!) voorbeeld(!) code wellicht om je probleem te illustreren? Kun je een simpele testcase maken in een paar, hooguit paar tiental, regels code?

[ Voor 16% gewijzigd door RobIII op 31-03-2024 23:47 ]

[Anoniem: 80910]

PHP:

foreach($chunks as $nr => $chunk){
                $closures = [];
                $forks = count($chunk);
                for($i = 0; $i < $forks; $i++){
                    $closures[] = function () use ($object, $parse, $chunk, $i) {
                        if(array_key_exists($i, $chunk)){
                            $parameter = [];
                            $parameter[] = $chunk[$i];
                            $parameter = Config::parameters($object, $parameter);
                            $data = SharedMemory::read($object, $parameter[0]);
                            if(in_array($data,[null, false], true)){
                                $data = Core::object(File::read($parameter[0], Core::OBJECT_JSON));
                                $write = SharedMemory::write($object, $parameter[0], $data);
                                echo 'write: ' . $write . PHP_EOL;
                            }                            
                        }
                        exit();
                    };
                }
                $list = ForkMultiple::new()->multiple($closures);

bovenstaande is mijn code: chunks haalt ie uit een json bestand en worden per aantal threads gechunked.
Het is niet het X-Y probleem. ik geef aan dat shmop niet werkt, die zou ik graag werkend willen hebben in mijn framework, want framework en ik vind shmop beter als memcached, redis of consorten.

ForkMultiple is de parent van Fork van spatie/fork. kijk 21.600.000 requests per dag is heel wat anders dan 60.000.000+ "parse->compile()" per dag.

ForkMultple is net iets anders dan fork, de closures zijn een array ipv 1 closure, want 1 closure kon ik niet dynamisch maken.

PHP:

<?php
namespace ...;


use Spatie\Fork\Fork;
use Spatie\Fork\Task;

class ForkMultiple extends Fork {

    public static function new(): self
    {
        return new self();
    }

    public function multiple($callables = []): array
    {
        $tasks = [];
        foreach ($callables as $nr => $callable) {
            $tasks[] = Task::fromCallable($callable, $nr);
        }

        return $this->waitFor(...$tasks);
    }

}

Opcache en compilen kost cpu kracht shmop weinig denk ik...

En volgens mij was mijn sharedmemory bijna even snel als opcache, dus kan een factor 3 schelen.

[ Voor 3% gewijzigd door Anoniem: 80910 op 01-04-2024 00:11 ]

[Creepy]

Nergens in je code zit iets van shmop of fork. Als je echt hulp wil dan is een minimaal stukje code met daarin je probleem reproduceerbaar toch echt wel iets dat je minimaal moet kunnen geven ipv framework code die niemand anders heeft dan jij.

Dus kan je dit reproduceren door shared memory te gebruiken in een child process zonder enige code van je framework? (Ik denk dat je wil proberen te zeggen dat shared memory in een php child process niet werkt., en dat zou gek zijn aangezien shared memory bedoelt is om tussen processen te delen...)

[Anoniem: 80910]

Hier staat de sharedMemory class: https://github.com/r3m-io...c/Module/SharedMemory.php ik moest het beknopt houden en zei dat het in de main thread het wel werkte.

[RobIII]

Anoniem: 80910 schreef op maandag 1 april 2024 @ 00:20:
Hier staat de sharedMemory class: https://github.com/r3m-io...c/Module/SharedMemory.php ik moest het beknopt houden en zei dat het in de main thread het wel werkte.

~200 regels uncommented code. Als je geholpen wil worden moet je ons helpen je te helpen. Je probleem duidelijk maken ("shmop werkt niet" -> wat werkt er niet, krijg je foutmeldingen?) en een simpele demonstratie om je probleem te reproduceren (en dat is dus niet linken naar je repo en 't ons zelf laten uitpuzzelen).

We willen je best helpen, maar op deze manier is 't behoorlijk lastig.

Creepy schreef op maandag 1 april 2024 @ 00:12:
aangezien shared memory bedoelt is om tussen processen te delen...

offtopic:
Ik had je haast niet herkend; nieuw avatar?

Waarbij je wel iets aan synchronisatie zult moeten doen (mutex, semaphores ofzo).

Wat ik zo snel, op 't oog, kan destilleren uit de code en dit topic is dat er iets uit een blok geheugen gelezen wordt wat vervolgens gedeserialised wordt en dan teruggeschreven in hetzelfde stuk geheugen?

[ Voor 36% gewijzigd door RobIII op 01-04-2024 00:41 ]

[Anoniem: 80910]

Sharedmemory doet een read op basis van parameter[0], een url / pad.

Als die read, null of false retourneert ,dan doet ie een file read vanaf de ramdisk. Dit probeert die vervolgens weg te schrijven onder parameter[0] , url / pad in sharedMemory. Write retourneert een int. Maar bij de echo is $write leeg.

De data is een json string op 1 regel.

By the way, het is iets complexer dan gemiddeld en lastig uit te leggen blijkt.

SharedMemory werkt in de main thread, maar niet in de child threads. En blijven mijn read en writes leeg zonder exception.

Undocumented code, klopt op het moment is de documentatie site offline, wordt ook aan gewerkt, maar ik heb geen haast en ik kan mijn code lezen.

[ Voor 29% gewijzigd door Anoniem: 80910 op 01-04-2024 00:58 ]

[DataGhost]

Maak eens een simpel stukje code van 10 of maximaal 20 regels, zonder je framework, met alleen het minimale wat je nodig hebt om shm te lezen/schrijven en je ding te forken. Werkt dat? Dan heb je ergens anders een issue. Werkt dat niet? Dan kunnen we meekijken zonder de honderden overbodige regels waar waarschijnlijk ook bugs in zitten.

[Anoniem: 80910]

Ik denk dat ik sharedMemory ga deprecaten. En verder met ramdisk.

By the way, knap als jij dat in 20 regels kan, ik niet, ook geen behoefte aan.

Maar bij jullie werkt het wel ? Wat gebruiken jullie daarvoor?

[RobIII]

Anoniem: 80910 schreef op maandag 1 april 2024 @ 01:02:
Ik denk dat ik sharedMemory ga deprecaten. En verder met ramdisk.

Je geeft nu al op? In amper 3 uur, op een zondagavond, in een paasweekend... wie weet krijg je morgen of dinsdag wel van iemand de/een oplossing die voor jou werkt...

Anoniem: 80910 schreef op maandag 1 april 2024 @ 01:02:
By the way, knap als jij dat in 20 regels kan, ik niet, ook geen behoefte aan.

In de documentatie kan 't ook (ex. het "fork gedeelte") en daar staat nog een hoop 'voorbeeld/debug' code in; als ik het terugbreng naar de relevante code is 't 5 regels:

PHP:

<?php
$shm_id = shmop_open(0xff3, "c", 0644, 100);
$shm_bytes_written = shmop_write($shm_id, "my shared memory block", 0);
$my_string = shmop_read($shm_id, 0, $shm_size);
shmop_delete($shm_id);
shmop_close($shm_id);

_{Waarbij regels 5 en 6 voor een testcase overigens ook nog vrij irrelevant zijn}

Daar nog je "fork deel" bij moet makkelijk binnen een 10, 20 regels kunnen lijkt me. Al wordt 't 30 of 40, als het maar een duidelijke, simpele, rechttoe-rechtaan, testcase is die je probleem reproduceert. Maar je kunt van niemand verwachten honderden regels code en 'vreemde' (als in: onbekende) frameworks te gaan leren en doorgronden om je te proberen helpen.

Anoniem: 80910 schreef op maandag 1 april 2024 @ 01:02:
Wat gebruiken jullie daarvoor?

Definieer 'daarvoor'? Het is mij (en volgens mij ons) nog steeds niet duidelijk welk probleem je aan 't oplossen bent en waarom je daarvoor shared memory gebruikt. Wat is het probleem dat je aan 't oplossen bent?

Je hebt ook nog steeds niet verduidelijkt met wat je bedoelt met "werkt niet".

[ Voor 35% gewijzigd door RobIII op 01-04-2024 01:12 ]

[Anoniem: 80910]

laat maar zitten, dit werkt niet