Giter Club home page Giter Club logo

codeczstd.jl's People

Contributors

ararslan avatar bicycle1885 avatar dependabot[bot] avatar jakobnissen avatar joaoaparicio avatar juliatagbot avatar mkitti avatar nhz2 avatar ranocha avatar sjkelly avatar viralbshah avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar

codeczstd.jl's Issues

Compilation error with `CodecZstd.jl` and `PackageCompiler#v1.6.0`

Hello,

I seem to be encountering a strange error when compiling a module which list PackageCompiler and CodecZstd as dependencies

Please consider :

module Foo

using Pkg, CodecZstd, PackageCompiler

julia_main()::Cint = 0

create_app_Foo(; kwargs...) = create_app(pkgdir(Foo), normpath(joinpath(pkgdir(Foo), "..", "$(Foo)_App")); kwargs...)

end # end Foo

When running

julia> using Foo; Foo.create_app_Foo(; force=true)

I get the following error

Stacktrace
[ Info: Precompiling Foo [f2f46d47-1d1a-4e6d-96f8-220910b5324c]
[ Info: PackageCompiler: creating base system image (incremental=false)...
[ Info: PackageCompiler: creating system image object file, this might take a while...
[ Info: PackageCompiler: creating system image object file, this might take a while...
ERROR: LoadError: LoadError: LoadError: could not load symbol "ZSTD_maxCLevel":
/home/user/julia-1.6.1/bin/julia: undefined symbol: ZSTD_maxCLevel
Stacktrace:
  [1] max_clevel()
    @ CodecZstd ~/.julia/packages/CodecZstd/vGFup/src/libzstd.jl:14
  [2] top-level scope
    @ ~/.julia/packages/CodecZstd/vGFup/src/libzstd.jl:17
  [3] include(mod::Module, _path::String)
    @ Base ./Base.jl:386
  [4] include(x::String)
    @ CodecZstd ~/.julia/packages/CodecZstd/vGFup/src/CodecZstd.jl:1
  [5] top-level scope
    @ ~/.julia/packages/CodecZstd/vGFup/src/CodecZstd.jl:20
  [6] include
    @ ./Base.jl:386 [inlined]
  [7] _require(pkg::Base.PkgId)
    @ Base ./loading.jl:1050
  [8] require(uuidkey::Base.PkgId)
    @ Base ./loading.jl:914
  [9] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:901
 [10] include
    @ ./Base.jl:386 [inlined]
 [11] _require(pkg::Base.PkgId)
    @ Base ./loading.jl:1050
 [12] require(uuidkey::Base.PkgId)
    @ Base ./loading.jl:914
 [13] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:901
in expression starting at /home/user/.julia/packages/CodecZstd/vGFup/src/libzstd.jl:17
in expression starting at /home/user/.julia/packages/CodecZstd/vGFup/src/CodecZstd.jl:1
in expression starting at /home/user/.julia/dev/Foo/src/Foo.jl:1
ERROR: failed process: Process(`/home/user/julia-1.6.1/bin/julia --color=yes --startup-file=no '--cpu-target=generic;sandybridge,-xsaveopt,clone_all;haswell,-rdrnd,base(1)' --sysimage=/tmp/jl_du3rkN/tmp_sys.so --project=/home/user/.julia/dev/Foo --output-o=/tmp/jl_Xnt4NN.o -e "Base.reinit_stdio()
@eval Sys BINDIR = ccall(:jl_get_julia_bindir, Any, ())::String
@eval Sys STDLIB = \"/home/user/julia-1.6.1/share/julia/stdlib/v1.6\"
Base.init_load_path()
if isdefined(Base, :init_active_project)
    Base.init_active_project()
end
Base.init_depot_path()
import Foo
# This @eval prevents symbols from being put into Main
@eval Module() begin
    using Base.Meta
    PrecompileStagingArea = Module()
    for (_pkgid, _mod) in Base.loaded_modules
        if !(_pkgid.name in (\"Main\", \"Core\", \"Base\"))
            eval(PrecompileStagingArea, :(const \$(Symbol(_mod)) = \$_mod))
        end
    end
    precompile_files = String[
        \"/tmp/jl_QBYBSN\"
    ]
    for file in precompile_files, statement in eachline(file)
        try
            # println(statement)
            # This is taken from https://github.com/JuliaLang/julia/blob/2c9e051c460dd9700e6814c8e49cc1f119ed8b41/contrib/generate_precompile.jl#L375-L393
            ps = Meta.parse(statement)
            isexpr(ps, :call) || continue
            popfirst!(ps.args) # precompile(...)
            ps.head = :tuple
            l = ps.args[end]
            if (isexpr(l, :tuple) || isexpr(l, :curly)) && length(l.args) > 0 # Tuple{...} or (...)
                # XXX: precompile doesn't currently handle overloaded Vararg arguments very well.
                # Replacing N with a large number works around it.
                l = l.args[end]
                if isexpr(l, :curly) && length(l.args) == 2 && l.args[1] === :Vararg # Vararg{T}
                    push!(l.args, 100) # form Vararg{T, 100} instead
                end
            end
            # println(ps)
            ps = Core.eval(PrecompileStagingArea, ps)
            # XXX: precompile doesn't currently handle overloaded nospecialize arguments very well.
            # Skipping them avoids the warning.
            ms = length(ps) == 1 ? Base._methods_by_ftype(ps[1], 1, Base.get_world_counter()) : Base.methods(ps...)
            ms isa Vector || continue
            precompile(ps...)
        catch e
            # See julia issue #28808
            @debug \"failed to execute \$statement\"
        end
    end
end # module
Base.@ccallable function julia_main()::Cint
    try
        Foo.julia_main()
    catch
        Core.print(\"julia_main() threw an unhandled exception\")
        return 1
    end
end
empty!(LOAD_PATH)
empty!(DEPOT_PATH)
"`, ProcessExited(1)) [1]

Stacktrace:
  [1] pipeline_error
    @ ./process.jl:525 [inlined]
  [2] run(::Cmd; wait::Bool)
    @ Base ./process.jl:440
  [3] run
    @ ./process.jl:438 [inlined]
  [4] create_sysimg_object_file(object_file::String, packages::Vector{String}; project::String, base_sysimage::String, precompile_execution_file::Vector{String}, precompile_statements_file::Vector{String}, cpu_target::String, script::Nothing, isapp::Bool, sysimage_build_args::Cmd)
    @ PackageCompiler ~/.julia/packages/PackageCompiler/r8Xcy/src/PackageCompiler.jl:371
  [5] create_sysimage(packages::Vector{String}; sysimage_path::String, project::String, precompile_execution_file::Vector{String}, precompile_statements_file::Vector{String}, incremental::Bool, filter_stdlibs::Bool, replace_default::Bool, base_sysimage::String, isapp::Bool, julia_init_c_file::Nothing, version::Nothing, compat_level::String, soname::String, cpu_target::String, script::Nothing, sysimage_build_args::Cmd)
    @ PackageCompiler ~/.julia/packages/PackageCompiler/r8Xcy/src/PackageCompiler.jl:538
  [6] (::PackageCompiler.var"#14#16"{Bool, Nothing, Nothing, String, Cmd, String, Vector{String}, Vector{String}, Bool, Bool, String, String, String, String, Bool})()
    @ PackageCompiler ~/.julia/packages/PackageCompiler/r8Xcy/src/PackageCompiler.jl:978
  [7] cd(f::PackageCompiler.var"#14#16"{Bool, Nothing, Nothing, String, Cmd, String, Vector{String}, Vector{String}, Bool, Bool, String, String, String, String, Bool}, dir::String)
    @ Base.Filesystem ./file.jl:106
  [8] _create_app(package_dir::String, dest_dir::String, name::Nothing, precompile_execution_file::Vector{String}, precompile_statements_file::Vector{String}, incremental::Bool, filter_stdlibs::Bool, audit::Bool, force::Bool, cpu_target::String; library_only::Bool, c_driver_program::String, julia_init_c_file::Nothing, header_files::Vector{String}, version::Nothing, compat_level::String, include_lazy_artifacts::Bool, sysimage_build_args::Cmd)
    @ PackageCompiler ~/.julia/packages/PackageCompiler/r8Xcy/src/PackageCompiler.jl:968
  [9] #create_app#11
    @ ~/.julia/packages/PackageCompiler/r8Xcy/src/PackageCompiler.jl:771 [inlined]
 [10] create_app_Foo(; kwargs::Base.Iterators.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:force,), Tuple{Bool}}})
    @ Foo ~/.julia/dev/Foo/src/Foo.jl:7
 [11] top-level scope
    @ REPL[1]:1

Of note:

  • This does not seem to be a problem for PackageCompiler.create_sysimage()
  • I'm not having any problems when Foo.jl doesn't list PackageCompiler directly + using PackageCompiler from the v1.6 env.This note was a mistake, please see message bellow
  • I've not tried this with any other TranscodingStreams.jl codec packages

Version
julia> versioninfo()
Julia Version 1.6.1
Commit 6aaedecc44 (2021-04-23 05:59 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Core(TM) i7-5820K CPU @ 3.30GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-11.0.1 (ORCJIT, haswell)
Project
name = "Foo"
uuid = "f2f46d47-1d1a-4e6d-96f8-220910b5324c"
authors = ["= <user> and contributors"]
version = "0.1.0"

[deps]
CodecZstd = "6b39b394-51ab-5f42-8807-6242bab2b4c2"
PackageCompiler = "9b87118b-4619-50d2-8e1e-99f35a4d4d9d"
Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[compat]
julia = "1"

Manifest
# This file is machine-generated - editing it directly is not advised

[[ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[CodecZstd]]
deps = ["TranscodingStreams", "Zstd_jll"]
git-tree-sha1 = "d19cd9ae79ef31774151637492291d75194fc5fa"
uuid = "6b39b394-51ab-5f42-8807-6242bab2b4c2"
version = "0.7.0"

[[Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.3.0"

[[LazyArtifacts]]
deps = ["Artifacts", "Pkg"]
uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"

[[LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[PackageCompiler]]
deps = ["LazyArtifacts", "Libdl", "Pkg", "UUIDs"]
git-tree-sha1 = "d2f93cc940b4a3d1aba77b266cbd7c7d404568c7"
uuid = "9b87118b-4619-50d2-8e1e-99f35a4d4d9d"
version = "1.6.0"

[[Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[Preferences]]
deps = ["TOML"]
git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.2"

[[Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[Random]]
deps = ["Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[TranscodingStreams]]
deps = ["Random", "Test"]
git-tree-sha1 = "216b95ea110b5972db65aa90f88d8d89dcb8851c"
uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
version = "0.9.6"

[[UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "cc4bf3fdde8b7e3e9fa0351bdeedba1cf3b7f6e6"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.0+0"

[[nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

Please let me know if you need additional details.

compression level support

It seems that different compression levels are not supported (although level is passed to the ccall of ZSTD_initCStream in libzstd.jl):

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.4.0 (2020-03-21)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> using Pkg; Pkg.status("CodecZstd")
Status `~/.julia/environments/v1.4/Project.toml`
  [6b39b394] CodecZstd v0.7.0

julia> using CodecZstd

julia> data = rand(0xa:0xb, 10^6); # something compressible

julia> unique(length(transcode(ZstdCompressor(level=level), data)) for level in 1:22)
# returns a 1-element array, so the compressed length is independent of level

Tips for debugging or understanding this?

slower than expected decompression

Hi, great packages, thanks for writing them! I'm trying to figure out the source of some overhead I'm seeing when decompressing via transcode vs. using the zstandard Python wrapper.

Using the zstandard Python wrapper:

In [89]: d = zstd.ZstdDecompressor()

In [90]: byts = open('recordings.ordered.json.zst', 'rb').read();

In [91]: %timeit -n 1 -r 1 d.decompress(byts)
481 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)

Using this package + TranscodingStreams:

julia> bytes = read("recordings.ordered.json.zst");

julia> @time transcode(ZstdDecompressor, bytes);
  2.748998 seconds (22 allocations: 256.937 MiB, 39.16% gc time)

If it helps, recordings.ordered.json.zst is ~16 MB and decompresses to ~620 MB.

random access/seek support

ref facebook/zstd#395 (comment)
ref https://discourse.julialang.org/t/ann-onda-jl-a-format-for-multi-sensor-multi-channel-lpcm-encodable-recordings/32650/3

I'm not sure if the upstream zstd's seek support is considered stable enough to support here, or what the most desirable interface would be from a TranscodingStreams perspective, but it would definitely useful if this feature was useable with CodecZstd.

Even if the upstream seekable format is still considered experimental, it may still be worthwhile to support here; the referenced thread makes it seem like more downstream usage of the experimental API would motivate further development/codification of the seekable format.

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Lots of allocations related to buffering

julia> data = rand(Float32, 1_000_000);

julia> io = open("foo", "w");

julia> zio = CodecZstd.ZstdCompressorStream(io);

julia> @time write(zio, data)
  0.023578 seconds (60.39 k allocations: 2.623 MiB)
4000000

julia> @time write(zio, data)
  0.024188 seconds (60.39 k allocations: 2.623 MiB)
4000000

julia> zio = CodecZstd.ZstdCompressorStream(io, bufsize=500_000);

julia> @time write(zio, data)
  0.011804 seconds (1.02 k allocations: 44.641 KiB)
4000000

julia> @time write(zio, data)
  0.013522 seconds (1.16 k allocations: 51.016 KiB)
4000000

julia> zio = CodecZstd.ZstdCompressorStream(io, bufsize=5_000_000);

julia> @time write(zio, data)
  0.002285 seconds (1 allocation: 16 bytes)
4000000

julia> @time write(zio, data)
  0.015165 seconds (146 allocations: 6.391 KiB)
4000000

julia> @time write(zio, data)
  0.017407 seconds (146 allocations: 6.391 KiB)
4000000

This is a very simple MWE of a typical use case for CodecZstd - writing to a file. It seems to cause an unexpectedly large amount of allocations. They seem to be related to the buffer size, presumably a bug in the growth or re-use of buffers.

Performance CodecZstd vs CodecZlib

Hi,

I am trying to compare ZstdDecompressorStream with GzipDecompressorStream.
Let's consider a dataframe with two random float columns, compressed using zstd and gzip.

973M stats.csv
423M stats.csv.gz
448M stats.csv.zst

ZStd uncompress faster:

  • 5.519s for time zcat stats.csv.gz > /dev/null

  • 1.754s for time zstdcat stats.csv.zst > /dev/null

In Julia, I use the following to load the dataframe (taken from here):

using CodecZstd, CodecZlib, CSVFiles, DataFrames, FileIO

function loader(file_name, decompressor)
  open(file_name) do io
    load(Stream(format"CSV", decompressor(io))) |> DataFrame
  end
end

With that code, I consistently get the following results:

julia> @time DataFrame(load("stats.csv"));
  2.425661 seconds (534 allocations: 1.002 GiB, 3.74% gc time)

julia> @time loader("stats.csv.gz", GzipDecompressorStream);
 10.230154 seconds (249.48 k allocations: 2.082 GiB, 1.71% gc time)

julia> @time loader("stats.csv.zst", ZstdDecompressorStream);
 16.919650 seconds (62.90 k allocations: 2.079 GiB, 1.15% gc time)

I am surprised to see that ZstdDecompressorStream is slower despite the gains seen above in decompression.

Are those results expected for the following versions of the packages?

(v1.1) pkg> st
    Status `~/.julia/environments/v1.1/Project.toml`
  [5d742f6a] CSVFiles v0.15.0
  [944b1d66] CodecZlib v0.6.0
  [6b39b394] CodecZstd v0.6.1
  [a93c6f00] DataFrames v0.19.2
  [5789e2e9] FileIO v1.0.7
julia> versioninfo()
Julia Version 1.1.1
Commit 55e36cc308 (2019-05-16 04:10 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, skylake)

Seg faults for large arrays

using CodecZstd
A = rand(Float32,3,137,451,900)    # some large array O(700MB)

for i in 1:3
    Ar = A[i,:,:,:]     # O(200MB)
    A8 = unsafe_wrap(Array, Ptr{UInt8}(pointer(Ar)), sizeof(Ar))     # reinterpret as Vector{UInt8}
    Ac = transcode(ZstdCompressor,A8)     # this segfaults on the first iteration
end

yields

signal (11): Segmentation fault: 11
in expression starting at /Users/milan/Desktop/test2.jl:5
_platform_memmove$VARIANT$Haswell at /usr/lib/system/libsystem_platform.dylib (unknown line)
Allocations: 58002064 (Pool: 57988345; Big: 13719); GC: 42
zsh: segmentation fault  "/Applications/Julia-1.5.app/Contents/Resources/julia/bin/julia" --depwarn=ye

How can I avoid this issue?

slower than expected decompression, round 2

Spiritual successor to #13; not sure what the culprit is this time:

julia> using CodecZstd, TranscodingStreams

julia> bytes = read("fid_1509_2018_LTM.edf.zst");

julia> @time transcode(ZstdDecompressor, bytes);
 27.252612 seconds (594.62 k allocations: 1.858 GiB, 0.02% gc time)
>>> import zstandard as zstd
>>> import timeit
>>> byts = open('fid_1509_2018_LTM.edf.zst', 'rb').read();
>>> d = zstd.ZstdDecompressor()
>>> timeit.timeit("d.decompress(byts)", number=1, globals=globals())
3.793142723850906

platform_key deprecated, build fails, error message refers to CodecZlib

I got the error message with TableReader

julia> using TableReader
[ Info: Precompiling TableReader [70df011a-6618-58d7-8e16-3cf9e384cb47]
ERROR: Error while loading expression starting at /home/tamas/.julia/packages/CodecZstd/Mf03f/src/CodecZstd.jl:20
caused by [exception 1]
CodecZlib.jl is not installed properly, run Pkg.build("CodecZlib") and restart Julia.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] top-level scope at /home/tamas/.julia/packages/CodecZstd/Mf03f/src/CodecZstd.jl:21

which, I think refers to the wrong package? Also, when I try to build (I have errors enabled for depwarns)

(v1) pkg> build CodecZstd
  Building CodecZstd → `~/.julia/packages/CodecZstd/Mf03f/deps/build.log`
┌ Error: Error building `CodecZstd`: 
│ ERROR: Error while loading expression starting at /home/tamas/.julia/packages/CodecZstd/Mf03f/deps/build.jl:31
│ caused by [exception 1]
│ platform_key() is deprecated, use platform_key_abi() from now on
│ Stacktrace:
│  [1] depwarn(::String, ::Symbol) at ./deprecated.jl:77
│  [2] platform_key(::String) at /home/tamas/.julia/packages/BinaryProvider/4F5Hq/src/CompatShims.jl:10 (repeats 2 times)
│  [3] top-level scope at /home/tamas/.julia/packages/CodecZstd/Mf03f/deps/build.jl:31
│  [4] include at ./boot.jl:328 [inlined]
│  [5] include_relative(::Module, ::String) at ./loading.jl:1094
│  [6] include(::Module, ::String) at ./Base.jl:31
│  [7] include(::String) at ./client.jl:431
│  [8] top-level scope at none:5
└ @ Pkg.Operations ~/src/julia-git/usr/share/julia/stdlib/v1.2/Pkg/src/backwards_compatible_isolation.jl:626

(v1) pkg> st --manifest TableReader
    Status `~/.julia/environments/v1/Manifest.toml`
  [ba30903b] CodecXz v0.5.0
  [944b1d66] CodecZlib v0.5.2
  [6b39b394] CodecZstd v0.5.0
  [a93c6f00] DataFrames v0.17.1
  [70df011a] TableReader v0.3.0
  [3bb67fe8] TranscodingStreams v0.9.3
  [ade2ca70] Dates 
  [de0858da] Printf 
  [9abbd945] Profile 
  [8dfed614] Test 
  [4ec0a83e] Unicode 

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.