function test_space($testname, $data)
{
    $phplen = strlen(serialize($data));
    $igbinarylen = strlen(igbinary_serialize($data));
    printf("  php     : %5u\n", $phplen);
    printf("  igbinary: %5u (%.02f%%)\n", $igbinarylen, $igbinarylen * 100 / $phplen);
}

 /**
  * @param mixed $data Data to serialize
  * @param bool $useIgBinary Use igBinary extension if supported
  *
  * @return string
  */
 protected function phpSerialize($data, $useIgBinary = true)
 {
     if ($this->isIgBinarySupported() && $useIgBinary) {
         return igbinary_serialize($data);
     }
     return serialize($data);
 }

 /**
  * Freezes this cache backend.
  *
  * All data in a frozen backend remains unchanged and methods which try to add
  * or modify data result in an exception thrown. Possible expiry times of
  * individual cache entries are ignored.
  *
  * On the positive side, a frozen cache backend is much faster on read access.
  * A frozen backend can only be thawed by calling the flush() method.
  *
  * @return void
  * @throws \RuntimeException
  */
 public function freeze()
 {
     if ($this->frozen === true) {
         throw new \RuntimeException(sprintf('The cache "%s" is already frozen.', $this->cacheIdentifier), 1323353176);
     }
     $cacheEntryFileExtensionLength = strlen($this->cacheEntryFileExtension);
     for ($directoryIterator = new \DirectoryIterator($this->cacheDirectory); $directoryIterator->valid(); $directoryIterator->next()) {
         if ($directoryIterator->isDot()) {
             continue;
         }
         if ($cacheEntryFileExtensionLength > 0) {
             $entryIdentifier = substr($directoryIterator->getFilename(), 0, -$cacheEntryFileExtensionLength);
         } else {
             $entryIdentifier = $directoryIterator->getFilename();
         }
         $this->cacheEntryIdentifiers[$entryIdentifier] = true;
         $cacheEntryPathAndFilename = $this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension;
         $lock = new Lock($cacheEntryPathAndFilename);
         file_put_contents($cacheEntryPathAndFilename, $this->internalGet($entryIdentifier, false));
         $lock->release();
     }
     $cachePathAndFileName = $this->cacheDirectory . 'FrozenCache.data';
     $lock = new Lock($cachePathAndFileName);
     if ($this->useIgBinary === true) {
         file_put_contents($cachePathAndFileName, igbinary_serialize($this->cacheEntryIdentifiers));
     } else {
         file_put_contents($cachePathAndFileName, serialize($this->cacheEntryIdentifiers));
     }
     $lock->release();
     $this->frozen = true;
 }

	protected function serialize ($value) {
		if ($this->igbinary) {
			return igbinary_serialize($value);
		}

		return serialize($value);
	}

 public function serialize($data)
 {
     if ($this->igbinary) {
         return igbinary_serialize($data);
     }
     return serialize($data);
 }

function bench($value, $n = 1000000)
{
    $benchmark = new Benchmark();
    $benchmark->add('serialize', function () use(&$value) {
        serialize($value);
    });
    $benchmark->add('json_encode', function () use(&$value) {
        json_encode($value);
    });
    if (function_exists('bin_encode')) {
        $benchmark->add('bin_encode', function () use(&$value) {
            bin_encode($value);
        });
    }
    if (function_exists('bson_encode')) {
        $benchmark->add('bson_encode', function () use(&$value) {
            bson_encode($value);
        });
    }
    if (function_exists('msgpack_pack')) {
        $benchmark->add('msgpack_pack', function () use(&$value) {
            msgpack_pack($value);
        });
    }
    if (function_exists('igbinary_serialize')) {
        $benchmark->add('igbinary_serialize', function () use(&$value) {
            igbinary_serialize($value);
        });
    }
    $benchmark->add('var_export', function () use(&$value) {
        var_export($value, true);
    });
    $benchmark->setCount($n);
    $benchmark->run();
}

 /**
  * Freezes this cache backend.
  *
  * All data in a frozen backend remains unchanged and methods which try to add
  * or modify data result in an exception thrown. Possible expiry times of
  * individual cache entries are ignored.
  *
  * On the positive side, a frozen cache backend is much faster on read access.
  * A frozen backend can only be thawed by calling the flush() method.
  *
  * @return void
  * @throws \RuntimeException
  */
 public function freeze()
 {
     if ($this->frozen === TRUE) {
         throw new \RuntimeException(sprintf('The cache "%s" is already frozen.', $this->cacheIdentifier), 1323353176);
     }
     $cacheEntryFileExtensionLength = strlen($this->cacheEntryFileExtension);
     for ($directoryIterator = new \DirectoryIterator($this->cacheDirectory); $directoryIterator->valid(); $directoryIterator->next()) {
         if ($directoryIterator->isDot()) {
             continue;
         }
         if ($cacheEntryFileExtensionLength > 0) {
             $entryIdentifier = substr($directoryIterator->getFilename(), 0, -$cacheEntryFileExtensionLength);
         } else {
             $entryIdentifier = $directoryIterator->getFilename();
         }
         $this->cacheEntryIdentifiers[$entryIdentifier] = TRUE;
         file_put_contents($this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension, $this->get($entryIdentifier));
     }
     if ($this->useIgBinary === TRUE) {
         file_put_contents($this->cacheDirectory . 'FrozenCache.data', igbinary_serialize($this->cacheEntryIdentifiers));
     } else {
         file_put_contents($this->cacheDirectory . 'FrozenCache.data', serialize($this->cacheEntryIdentifiers));
     }
     $this->frozen = TRUE;
 }

 /**
  * Store data on the cache server.
  *
  * @param string       $key        Key we can use to retrieve the data.
  * @param string|array $data       Data to store on the cache server.
  * @param int          $expiration Time before the data expires on the cache server.
  *
  * @return bool Success/Failure.
  * @access public
  */
 public function set($key, $data, $expiration)
 {
     if ($this->connected === true && $this->ping() === true) {
         return $this->server->set($key, $this->isRedis ? $this->IgBinarySupport ? igbinary_serialize($data) : serialize($data) : $data, $expiration);
     }
     return false;
 }

 /**
  * @dataProvider getTestData
  */
 public function testSerialize($value, $serialized, $expected = null)
 {
     if (!extension_loaded('igbinary')) {
         $this->markTestSkipped('The igbinary extension must be loaded');
     }
     $serialized = igbinary_serialize($value);
     parent::testSerialize($value, $serialized, $expected);
 }

 private function _tempData_serialize($data)
 {
     if (true === $this->_has_igbinary_status) {
         return igbinary_serialize($data);
     } else {
         return serialize($data);
     }
 }

 private static function serialize($o)
 {
     $igbinary = extension_loaded('igbinary');
     if ($igbinary) {
         return @igbinary_serialize($o);
     }
     return @serialize($o);
 }

/**
 * @param mixed $val
 * @return string
 */
function serialize($val)
{
    if (function_exists('igbinary_serialize')) {
        return \igbinary_serialize($val);
    } else {
        return \serialize($val);
    }
}

 private function _serialize($data)
 {
     if ($this->_has_igbinary) {
         return igbinary_serialize($data);
     } else {
         return serialize($data);
     }
 }

 /**
  */
 public function unpack($data)
 {
     $out = igbinary_unserialize($data);
     if (!is_null($out) || $data == igbinary_serialize(null)) {
         return $out;
     }
     throw new Horde_Pack_Exception('Error when unpacking serialized data.');
 }

 /**
  * @TODO DESCR
  * @param $p
  */
 public function sendPacket($p)
 {
     if ($p === null) {
         return;
     }
     $data = \igbinary_serialize($p);
     $this->write(pack('N', mb_orig_strlen($data)) . $data);
 }

 /**
  * 加密
  * @param $data 支持数据和字符串；
  * @return string 返回加密后的字符串
  */
 public function encrypt($data)
 {
     if (empty($data)) {
         return '';
     }
     $data = igbinary_serialize($data);
     $data = Yii::$app->getSecurity()->encryptByKey($data, self::$_key);
     return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
 }

 /**
  * serialize
  *
  * @param mixed $value
  *
  * @return string
  */
 public function serialize($value)
 {
     if (function_exists('igbinary_serialize')) {
         return igbinary_serialize($value);
     } else {
         // fallback
         return serialize($value);
     }
 }

 public static function pack($data)
 {
     if (function_exists("igbinary_serialize")) {
         $data = igbinary_serialize($data);
     } else {
         $data = serialize($data);
     }
     return self::PACKED_MARK . rtrim(base64_encode($data), "=");
 }

 /**
  * Store cell data in cache for the current cell object if it's "dirty",
  *     and the 'nullify' the current cell object
  *
  * @return	void
  * @throws	PHPExcel_Exception
  */
 protected function _storeData()
 {
     if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
         $this->_currentObject->detach();
         $this->_cellCache[$this->_currentObjectID] = igbinary_serialize($this->_currentObject);
         $this->_currentCellIsDirty = false;
     }
     $this->_currentObjectID = $this->_currentObject = null;
 }

 /**
  * Serialize PHP value to igbinary
  *
  * @param  mixed $value
  * @param  array $opts
  * @return string
  * @throws Zend_Serializer_Exception on igbinary error
  */
 public function serialize($value, array $opts = array())
 {
     $ret = igbinary_serialize($value);
     if ($ret === false) {
         $lastErr = error_get_last();
         throw new Zend_Serializer_Exception($lastErr['message']);
     }
     return $ret;
 }