juliaio / codeczstd.jl Goto Github PK
View Code? Open in Web Editor NEWA zstd codec for TranscodingStreams.jl.
License: Other
A zstd codec for TranscodingStreams.jl.
License: Other
It'd be nice to expose additional options that are available on the command line like --threads
, but it looks a bit more involved than just passing through an extra parameter:
https://zstd.docsforge.com/dev/code-examples/streaming_compression_thread_pool.c/
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
[ 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:
PackageCompiler.create_sysimage()
Foo.jl
doesn't list PackageCompiler
directly + using PackageCompiler
from the v1.6
env.TranscodingStreams.jl
codec packagesjulia> 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)
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"
# 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.
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?
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.
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.
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!
https://github.com/facebook/zstd/releases/tag/v1.5.5 fixes a corruption bug.
I'm interested in developing support in this package for building a dictionary using Zstd. I would probably start with making automatically generated bindings via Clang.jl for these headers:
https://github.com/facebook/zstd/blob/dev/lib/zdict.h
https://github.com/facebook/zstd/blob/dev/lib/zstd.h
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.
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)
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?
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
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
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.