[Draft][Bug] Undefined constant.

[inilim]

I'm still studying this issue, and I can't reproduce the error in a simple code. The error only occurs in the production project. Once I reproduce the error, I will update the question or even delete it.

use parallel\Future;
use parallel\Runtime;

class Flow
{
    protected Runtime $runtime;

    function exec(\Closure $callback, array $args = []): Task
    {
        // some code...

        $wrapTask = static function (\Closure $task, string $taskId, array $args) {
            /** @var (null|bool|int|float|string|\Closure|mixed[])[] $args */

            try {

                var_dump([
                    \Inilim\IPDO\IPDO::FETCH_IPDO_RESULT, // int(0) - value of the constant is correct
                    \defined('\Inilim\IPDO\IPDO::FETCH_IPDO_RESULT'), // bool(false) - first bug
                ]);

                \FLOW_TASK_REP->worked($taskId); // throw exception... second bug is related to the first bug, I think
                // "FLOW_TASK_REP" - this constant was defined in the previous task.

                $result = Other::timedMsCall(static function () use ($task, $args) {
                    try {
                        return $task(...$args);
                    } catch (\Throwable) {
                        return null;
                    }
                });

                \FLOW_TASK_REP->success($taskId, \json_encode([
                    'value' => $result['result'],
                    'time'  => $result['time'],
                ]));
            } catch (\Throwable $e) {
                VD::dde([
                    $e->getMessage(), // "Undefined constant Inilim\IPDO\IPDO::FETCH_IPDO_RESULT"
                    $e->getFile(),
                    $e->getLine(),
                ]);
            }
        };

        $this->futures[$task->id] = $this->runtime->run($wrapTask, [$callback, $task->id, $args]);

        return $task;
    }
}

Inside the "worked" method, there is a nested method with an argument that has a default value for a constant.

use Inilim\IPDO\IPDO;

// some code...

protected function internalMethod(
        \Closure $callback,
        string $sql,
        array $values = [],
        int $fetch = IPDO::FETCH_IPDO_RESULT
    ) {...}

PHP

PHP 8.4.9 (cli) (built: Jul  1 2025 15:27:25) (ZTS Visual C++ 2022 x64)
Copyright (c) The PHP Group
Zend Engine v4.4.9, Copyright (c) Zend Technologies

parallel version => 1.2.11
opcache - off

OS
Windows 10 Pro

[Razzatack]

In Hynes sight I could recommend what to do

[inilim]

@Razzatack

I'm all ears.

[Razzatack]

Use devices that you have access too physically not remotely

[realFlowControl]

Hey @inilim,

there are multiple things going on here, let's split it up:

var_dump([
    \Inilim\IPDO\IPDO::FETCH_IPDO_RESULT, // int(0)
    \defined('\Inilim\IPDO\IPDO::FETCH_IPDO_RESULT'), // bool(false)
]);

The access to the constant \Inilim\IPDO\IPDO::FETCH_IPDO_RESULT is folded by PHP at compile time. So when parallel copies that task into the runtime thread, it copies the opcodes, not the PHP source. At that point, the opcode already contains the resolved value, not the original class-constant access.

That folded value is misleading, so this is something I should look into.

The call to \defined('\Inilim\IPDO\IPDO::FETCH_IPDO_RESULT') is executed at runtime. PHP checks the runtime thread’s class table and returns false because the class/constant definition was not executed in that runtime.

\FLOW_TASK_REP->worked($taskId);
// "FLOW_TASK_REP" - this constant was defined in the previous task.

FLOW_TASK_REP is only available if it was defined earlier in the same parallel\Runtime. If work is dispatched across a pool/scheduler of runtimes, relying on a previous task’s definitions is unsafe: the next task may run in a different runtime whose class/function/constant table does not contain that state.

The general approach for this kind of state is to create your own runtime with $runtime = new \parallel\Runtime('path/to/bootstrap.php') and schedule all tasks that need that state on that runtime.

[inilim]

Hi @realFlowControl

As far as I remember, I used the first run() as a bootstrap (it was more convenient for me that way), as soon as the Runtime is created, I execute the first run() and a constant appears there, and the subsequent run() errors were returned.

Below is an example code of how it looked in practice.

<?php

use parallel\Runtime;

\error_reporting(\E_ALL);

class Flow
{
    protected Runtime $runtime;
    protected array $futures = [];
    protected int $counter = 0;
    protected bool $boot = false;
    protected bool $firstRun = false;

    function __construct()
    {
        $this->runtime = new Runtime;
    }

    function boot(\Closure $boot): self
    {
        if (true === $this->firstRun) {
            throw new \LogicException;
        }

        $this->futures[] = $this->runtime->run($boot);
        $this->boot = true;
        return $this;
    }

    function exec(\Closure $callback): self
    {
        if (false === $this->firstRun) {
            $this->firstRun = true;
        }

        $wrapTask = static function (\Closure $task, int $counter) {
            var_dump($counter);
            try {
                $task();
            } catch (\Throwable $e) {
                \print_r([
                    $e->getMessage(),
                    $e->getFile(),
                    $e->getLine(),
                ]);
            }
        };

        $this->futures[] = $this->runtime->run($wrapTask, [$callback, $this->counter]);
        $this->counter++;

        return $this;
    }
}

$flow = new Flow;

$flow->boot(static function () {
    // Is this correct? can there be side effects?
    require_once __DIR__ . '/vendor/autoload.php';
    Boot::init();
    var_dump('boot');
});

$flow->exec(static function () {
    var_dump(\SOME);
});

$flow->exec(static function () {
    var_dump(\SOME);
});

$flow->exec(static function () {
    var_dump(\SOME_STRING);
});

exit(PHP_EOL . 'main flow end' . PHP_EOL);

When this error occurred, I couldn't reproduce it in the test environment, and now I can't.