PHP Threading SimpleXMLElement

Question

I've searched EVERYWHERE for this and I'm having lots of problems, But I don't think it's a problem with the actual code. Basically this code starts the socket server(login and game) in two separate threads, I basically converted this code from a non-thread version but I've been unable to get this working for threads.

include "socket.php";
include "dep.php";

class Server extends Thread {
    public $server;
    public $config;
    public function __construct($type){
        //$this->config = (string)$type;
        $this->run2($type);
        $this->run();
    }
    public function run(){
        while(true){
            $this->server->loop();
        }
    }
    public function run2($config){
        $this->server = new sokserv($config);
        $this->server->init();
        //while(true){
        //  $this->server->loop();
        //}
    }
}
$login = new Server('Config/config.xml');
$game = new Server("Config/config2.xml");
The error received is 
Fatal error: Uncaught exception 'Exception' with message 'Serialization of 'SimpleXMLElement' is not allowed' in C:\Users\=\Desktop\Test\Start.php:19
Stack trace:
#0 C:\Users\=\Desktop\Test\Start.php(19): Server->run2()
#1 C:\Users\=\Desktop\Test\Start.php(10): Server->run2('Config/config.x...')
#2 C:\Users\=\Desktop\Test\Start.php(26): Server->__construct('Config/config.x...')
#3 {main}
  thrown in C:\Users\=\Desktop\Test\Start.php on line 19

However, reverting to the old code works fine. The first bit of sokserv(I removed some public vars because they contain personal info)

class sokserv
{
    public $ip;
    public $port;
    public $users = array();
    public $config;
    public $mysql;
    private $socket;
    public function __construct($config = "Config/config.xml")
    {
        $this->readConfig($config);
    }
    public function readConfig($file)
    {
        if (!file_exists($file))
            die("Could not find config");
        $this->config = simplexml_load_file($file);
    }

And if you wanted this is the xml:

<server>
    <port>6112</port>
    <ip>0</ip>
    <mysql>
        <host>127.0.0.1</host>
        <username>root</username>
        <dbname></dbname> 
        <password></password>
        <table></table>
    </mysql>
</server>

Answer 1

The Zend memory manager, with the help of TSRM, are purposefully built to prohibit contexts from sharing data; no context can allocate or free anything in another thread. This is referred to as a shared nothing architecture and it does exactly what it says on the tin. The job of pthreads is to breach that barrier in a safe, sane manner.

Obviously, none of the extensions bundled with PHP are aware of pthreads, nor do we want them to be, for they would just become vastly complicated. When it comes to objects provided by other extensions, pthreads makes the assumption that the safest thing to do is serialize the object for storage. Some objects prohibit this from occurring, SimpleXML descendants are one such group of objects.

Strings, floats, integers and objects that descend from pthreads are not serialized. Objects that descend from pthreads hi-jack the serialization API, storing the physical addressof the object, avoiding serialization by directly accessing the thread safe structure representing the object in userland.

The proper solution is to wrap the data you wish to share in an object descended from pthreads:

<?php
class Config extends Stackable {
    /**
    * Constructs thread safe, sharable configuration from complex XML
    * @param mixed $xml         SimpleXMLElement or location of XML file
    * @param array &$objects    reference store
    */
    public function __construct($xml, &$objects) {
        if ($xml instanceof SimpleXMLElement) {
            foreach ($xml as $key => $value)
                $this[$key] = (string) $value;
        } else {
            foreach (simplexml_load_string(
                        $xml) as $key => $value) {
                if ($value->children()) {
                    $this[$key] = new Config($value, $objects);
                } else $this[$key] = (string) $value;
            }
        }

        /* maintain object references */
        $objects[] = $this;
    }

    public function run() {}
}

class Test extends Thread {
    protected $config;

    /**
    * Constructs thread using pre-constructed thread safe, shared configuration object
    * @param Config $config
    */
    public function __construct(Config $config) {
        $this->config = $config;
    }

    public function run() {
        /* iterate over configuration */
        printf("%d settings:\n", count($this->config));
        foreach ($this->config as $key => $data) {
            if (count($data) > 1) {
                printf( 
                    "\t%s, %d settings:\n", $key, count($data));
                foreach ($data as $name => $value) {
                    printf("\t\t%s = %s\n", $name, $value);
                }
            } else printf("\t%s = %s\n", $key, $data);
        }
        printf("\n");

        printf(
            "Host: %s:%d\n", 
            $this->config->ip, 
            $this->config->port);

        printf(
            "MySQL: %s@%s?database=%s&password=%s&table=%s\n", 
            $this->config->mysql->username,
            $this->config->mysql->host,
            $this->config->mysql->dbname,
            $this->config->mysql->password,
            $this->config->mysql->table);
    }
}

/* Example XML */
$xml = <<<XML
<server>
    <port>6112</port>
    <ip>some.ip</ip>
    <mysql>
        <host>127.0.0.1</host>
        <username>root</username>
        <dbname>somedb</dbname> 
        <password>somepass</password>
        <table>sometable</table>
    </mysql>
</server>
XML;

/* Object reference storage */
$objects = [];
$config = new Config($xml, $objects);

$thread = new Test($config);
$thread->start();

$thread->join();
?>

Will output the following:

3 settings:
        port = 6112
        ip = some.ip
        mysql, 5 settings:
                host = 127.0.0.1
                username = root
                dbname = somedb
                password = somepass
                table = sometable

Host: some.ip:6112
MySQL: root@127.0.0.1?database=somedb&password=somepass&table=sometable

The example provided uses the [format] XML you provided in the question, it takes that XML and creates a thread safe representation of it, which will never be serialized.

The logic in the constructor of Config wholly depends upon the format of the XML you are using.

You can pass that Config object to as many threads as you wish, all of them can read/write properties, and execute it's methods.

All data that you intend to share should be managed in this way, what you want to take away from this is not that you should work around the exception and try to store serial data, but rather that you should create suitable containers for your data that actually support, properly, multi-threading.

Further reading: https://gist.github.com/krakjoe/6437782

Answer 2

Because PHP does not natively support sharing data between threads, the pthreads code is serializing data that needs to be shared between two threads, so it can create a clean copy in another thread when needed (by unserializing it). The exceptions to this are simple scalar types, which can be copied easily anyway, and the Thread, Worker, and Stackable objects which represent the actual tasks being executed, and have explicit support for synchronization.

Unfortunately, some PHP objects do not support serialization, because they are internally implemented as pointers to an in-memory structure, not just a set of PHP variables. SimpleXML is one example of this, hence the error message you are seeing.

There are a few ways around this, depending how "clever" you want to be:

• The simplest is not to parse the XML in your sokserv->readConfig method, or not to run that method straight away. Instead, you could store the filename, or the raw XML string, and parse it later. Each thread would then be creating its own SimpleXML object explicitly, and only the string would need to be passed between threads.
• Contrarily, you could parse the XML completely, extract the information you need into a simpler object, and then discard the SimpleXMLElement, all before starting the thread.
• Another possibility would be to give your sokserv class __sleep and __wakeUp methods, or make it implement the Serializable interface. In both cases, the idea would be to turn $this->config into an XML string on serialization/sleep, and back into a (new) SimpleXML object on unserialization/wake-up.
• The most advanced approach would be to wrap SimpleXMLElement itself with custom serialization behaviour. Note that a simple sub-class of SimpleXMLElement cannot reimplement the Serializable interface, as shown by this example. You would need instead to put the SimpleXMLElement into some container object or use the Delegation pattern.

Whatever approach you choose, the basic concept is the same: the data being passed between threads (attached to a Thread, Worker, or Stackable object) cannot be of a class such as SimpleXML which cannot be serialized.