标签: storable

在我的生产环境中,我们已经拥有了我们认为是由Storable.pm创建的腐败可存储哈希.我无法复制Dev中的行为,这使得很难准确诊断.

代码已经工作了很长时间,并且使其中断的更改是从哈希中删除.直到最近,散列要么保持相同的大小,要么增长.

该文件在readwrite中打开,然后store_fd写入该文件.由于哈希现在(有时)更小,它将写入1000字节到这个2000byte文件.尾部1000字节是旧的垃圾数据.在我的测试用例中,当我检索哈希时,垃圾数据会被忽略,如预期的那样.

open( $sf, "+< $self->{mod_state_filename}" );
flock( $sf, LOCK_EX );
$self->{mod_state} = fd_retrieve($sf);
delete ($self->{mod_state}{"somekey"});
seek( $sf, 0, 0 );
store_fd( $self->{mod_state}, $sf );
flock( $sf, LOCK_UN )
close($sf);

我的问题:

1. 这应该工作,还是我必须截断文件？
2. 存储的哈希是否使用某种文件终止符？如果是这样,它是什么？
3. 上面的代码,删除,添加,删除和添加,在我的测试用例中完美地运行.由于非截断文件,您能否建议任何可能导致其失败的测试用例序列？(我知道这是一个非常模糊的问题,所以请随意忽略它).

我是Moose的新手并且做得很好,直到我用PDL作为财产.我希望能够将一个对象写入一个文件(我一直在使用use MooseX::Storage; with Storage('io' => 'StorableFile');,这个对象有PDL一个属性.PDL::IO::Storable提供了Storable以这种方式使用的必要方法,但是我不知道如何在驼鹿.

这是一个例子,它有点长,我知道,但它尽可能少,我可以做到:

#!/usr/bin/perl

package LinearPDL;
use Moose;

use PDL::Lite;
use PDL::IO::Storable;

use MooseX::Storage; 
with Storage('io' => 'StorableFile');

has 'length' => (is => 'ro', isa => 'Num', required => 1);
has 'divisions' => (is => 'ro', isa => 'Int', required => 1);
has 'linear_pdl' => (is => 'ro', isa => 'PDL', lazy => 1, builder => '_build_pdl');

sub _build_pdl {
  my $self = shift;

  my $pdl = $self->length() …

我正在尝试解冻在64位Solaris(生产)计算机上使用Storable冻结的数据库BLOB.当我尝试在32位Windows(开发)PC上解冻时,我收到"字节顺序不兼容错误".

perl -v (on solaris)
This is perl, v5.8.8 built for i86pc-solaris-64

perl -v (on Windows)
This is perl, v5.10.1 built for MSWin32-x86-multi-thread

确切的错误是:

(Unable to read: Byte order is not compatible at blib\lib\Storable.pm (autosplit into  blib\lib\auto\Storable\thaw.al) line 415, at ../handlers/Search/actions/SearchSendQueue.pm line 124 )

SearchSendQueue.pm的第124行:

my $object = thaw( $item->{object} );

有谁知道如何在32位机器上解冻这个对象？

注意:该对象有效且可在64位生产计算机上运行.我已经尝试过"$ Storable :: interwork_56_64bit = 1;" 正如其他论坛所建议的那样

我为下面的数据类型写了一个可存储的矢量实例(原始问题在这里):

data Atoms = I GHC.Int.Int32 | S GHC.Int.Int16

用于为可存储矢量定义这些实例的代码如下.虽然我使用下面的代码获得了非常好的性能,但我对通用建议非常感兴趣,以提高该可存储实例的性能.通用建议,我的意思是:

• 它不是GHC编译器版本特有的.您可以假设GHC 6.12.3+排除性能错误(如果早期版本中存在任何错误,并且与此处的代码相关).
• 特定于平台的建议是可以的.您可以假设x86_64 Linux平台.
• 与利用特定于硬件的优化的建议相比,更多以算法改进(大O)形式的通用建议非常受重视.但是,考虑到像偷看/捅这样的基本操作,据我所知,算法改进的空间不大(因此它更有价值,因为它是一种稀缺的商品:)
• x86_64的编译器标志是可接受的(例如,告诉编译器有关删除浮点安全检查等).我使用"-O2 --make"选项来编译代码.

如果有任何已知的好的库源代码做类似的事情(即,为union/recursive数据类型定义可存储的实例),我将非常感兴趣检查它们.

import Data.Vector.Storable
import qualified Data.Vector.Storable as V
import Foreign
import Foreign.C.Types
import GHC.Int

data Atoms = I GHC.Int.Int32 | S GHC.Int.Int16
                deriving (Show)

instance Storable Atoms where
  sizeOf _ = 1 + sizeOf (undefined :: Int32)
  alignment _ = 1 + alignment (undefined :: Int32)

  {-# INLINE peek #-}
  peek p = do
            let p1 = (castPtr p::Ptr Word8) `plusPtr` …

我最近将一些Perl代码从SunSolaris迁移到64位的Linux(Ubuntu)盒子.迁移Storable.pm打破后出现以下错误:

Byte order is not compatible at /usr/lib/perl/5.18/Storable.pm, at /home/VD/Cache.pm line 347.

在互联网上进行一些研究后,我发现我需要使用nfreeze而不是thaw,但现在我收到以下错误:

not a reference at /home/VD/Cache.pm line 347.

有任何建议如何解决这个问题？

    sub get
    {
      my($self, $type, $param_ref) = @_;
       #return 1 if(!$self->{'INI'}{'sf.system.cache.enabled'});

if($self->{'INI'}{'sf.system.cache.database.enabled'})
{
    ### DATABASE
    my $param = $self->SF::Cache::convert_parameter($type, $param_ref);

    if($self->SF::Cache::CACHE_TABLE_USERCONTENT && $$param{'type'} == 2)
    {
        ### user-content
        my $query = 'SELECT PARAM_CONTENT AS C, DATA AS D FROM    sf_cache_usercontent WHERE SITE=? AND PARAM_USER=?';
        my $bindvar = { 1=>$self->{'site'}, 2=>$$param{'user'} };
        my $sth …

假设你有一个C结构

typedef struct {
  uint32_t num;
  char*    str;
} MyStruct;

以及对其f执行某些操作的函数,

void f(MyStruct* p);

C API要求char*在调用之前分配足够的缓冲区f:

char buf[64];   //the C API docs say 64
MyStruct s = {1, buf};
f(s);  // would go badly if MyStruct.str isn't alloc'ed

(请注意,该num字段在此构造示例中没有任何用途.它只是防止使用CString和的简单解决方案CStringLen.)

问题是如何为这种C API编写Haskell FFI.

我想出的是:开始

data MyStruct = MyStruct {
    num :: Word32,
    str :: String
} deriving Show

并写一个可存储的实例.我的想法是在末尾分配64个字节,它将作为字符串的缓冲区:

instance Storable MyStruct where
    sizeOf _ = 8{-alignment!-} + sizeOf …

PHP脚本可以反序列化使用Perl创建的可存储文件吗？

我很难理解是什么Storable.

我知道它将一个变量"存储"到你的磁盘中,但为什么我需要这样做呢？我将使用此模块,我将如何操作？

我有一个向量列表 - 类型集是已知和固定的 - 让我们说,CInt和CChar.该列表在编译时是未知的 - 组合将在运行时从配置文件中确定.例如,我们可能决定需要将两个向量传递给C函数:一个CInt长度为10的CChar向量,一个长度为50的向量.至于C函数如何解释它们,我可以通过传递每个向量的向量编码类型来处理该逻辑(比如说,0 => CInt,1 => CChar),并且传递了每个矢量的矢量编码长度(10,50).

我想弄清楚的是如何生成混合向量的向量(仅用于传递给C).我尝试了类似下面的玩具解决方案(它模拟相同的想法 - 生成Ptr混合类型的可存储向量- 在实际代码中,每个Ptr将指向另一个可存储向量).它因类型错误而失败 - 我怀疑它与之前在我之前提到的另一个问题中指出的存在性合格类型有关.由于我使用Storable实例传递给C FFI,我想我无法包装类型(没有定义另一个可存储的实例).

{-#  LANGUAGE BangPatterns, GADTs #-}
import Data.Vector.Storable as SV
import Foreign.C.Types (CChar, CInt)
import GHC.Int (Int32)
import Foreign.Marshal.Alloc
import Foreign.Ptr (Ptr)

mallocInt :: IO (Ptr CInt)
mallocInt = malloc

mallocChar :: IO (Ptr CChar)
mallocChar = malloc

main = do
  a <- mallocInt
  b <- mallocChar …

我不是Perl专家,所以这可能是一个简单的问题.

我一直在使用Storable,并按照这个例子来存储哈希.首先,我存储原始哈希.

use Storable qw(store retrieve freeze thaw dclone);
%color = ('Blue' => 1, 'Red' => 0.8, 'Black' => 0, 'White' => 1);
store(\%color, 'mycolors');

然后我找回它.(不同的脚本)

use Storable qw(store retrieve freeze thaw dclone);
$colref = retrieve('mycolors');
printf "Blue is still %lf\n", $colref->{'Blue'};

我的问题是如何更改其中一个哈希值？例如,做类似的事情

$colref->{'Blue'} = 2;
store(\%color, 'mycolors');

在第二个脚本中.

我不知道我的代码有什么问题.我正在尝试序列化父级内部的哈希并将其传递给fork,它应该在其中进行反序列化.

#!/usr/bin/perl
use strict;
use warnings;
use Storable qw(freeze thaw);
use IO::Pipe;

my $pipe_to_fork = IO::Pipe->new();

my $fork = fork;
if ($fork == 0) { # actual fork scope
  $pipe_to_fork->reader();
  my $hash_serialized = <$pipe_to_fork>; # wait and retrieve the serialized hash from parent
  chomp $hash_serialized;
  my %hash_rebuild = %{thaw($hash_serialized)}; # deserialize the retrieved serialized hash
  exit;
}

my %hash = ('key1' => "val1", 'key2' => "val2");

$pipe_to_fork->writer();
$pipe_to_fork->autoflush(1);

my $hash_serialized = freeze(\%hash); # serialize the hash
print $pipe_to_fork $hash_serialized."\n";
sleep …

我在Haskell模块中有以下数据类型,我想编写一个可存储的实例,将其与C通过FFI一起使用:

data MyType a =
        TypeDouble Double
      | TypeLst [a] 
      | TypeAdd (MyType a) (MyType a) 

我开始定义sizeOf函数:

instance Storable a => Storable (MyType a)  where
  sizeOf (TypeDouble _) = sizeOf (0 :: Double)
  sizeOf (TypeLst lst)  = sum $ map sizeOf lst
  sizeOf (TypeAdd a b)  = sizeOf a + sizeOf b

编译得很好,但我不知道如何实现peek和poke功能.我认为实现这些函数的方式与此答案相同,但只有当列表中的所有元素具有相同的大小(此处不是这种情况)时,此实现才起作用.

对于元素具有浮动大小的递归类型,实现peek和poke函数的正确方法是什么？

我需要使用DBI连接对象序列化一个数组,以使用共享内存与其他进程共享.但反序列化不起作用.

使用可存储的qw /冻融/;

my @connections;

for(my $c = 0;$c < 5;$c++) {
  my $conn = DBI->connect($dsn,$user,$password,{'AutoCommit' => 1, 'RaiseError' => 1, 'PrintError' => 0});
  push(@connections,$conn);
}

my $shm = freeze(@connections);
my $obj = thaw($shm);

返回错误:全局符号

"$ drh"需要明确的包名(您是否忘记在(eval 33)第6行声明"我的$ drh"？).