前言

本文用周k线的计算来举例，如何通过CUDA来实现GPU计算。

1、用日线来计算周线的方法：

（1）大盘（沪深300指数）如何计算周k线？

大盘不涉及停牌，所以直接按照week来划分数据，然后分别计算open、 high、 low、 close、 vol、 money几个值

（2）个股如何计算周线？

先调用大盘的周线信息，用大盘周线的起止日期去查询个股的日线数据，然后分别计算open、 high、 low、 close、 vol、 money以及停牌信息。

2、GPU计算相关

（1）julia中GPU计算的实现

a、直接用矢量化的计算

 a_gpu .+ b_gpu

b、用map reduce等类似的函数

c_gpu = CUDA.map(+,a_gpu,b_gpu)

c、自己编写cuda核函数
CPU和GPU之间数据的传输
用Array和CuArray

CPU在GPU上启动核函数后，如何等待GPU计算结束，并取回计算结果
用【sync】来实现

在GPU上创建的数组，操作完毕后，如何释放变量
用CUDA.unsafe_free!()来释放

blocks中线程数如何设置
每个block中thread最大数量不超过1024，具体查询CUDA官网，针对GPU计算能力值来设定

blocks块数如何设置
任务量 / 每块线程数，然后取ceil整数，就是blocks的数量

日线计算周线的CUDA核函数实现

"""
GPU核函数：生成周k线
#大盘信息
dapan_idx_d,
dapan_date_start_d,
dapan_date_end_d,
dapan_cnt_d,

#个股信息
arg_day_d,
arg_open_d,
arg_high_d,
arg_low_d,
arg_close_d,
arg_vol_d,
arg_money_d,

#返回值
rtn_idx_d,
rtn_day_d,
rtn_open_d,
rtn_high_d,
rtn_low_d,
rtn_close_d,
rtn_volume_d,
rtn_money_d,
rtn_cnt_dapan_d,
rtn_cnt_d,
"""
function gen_weekly_kline_kernel!(
    dapan_idx_d,
    dapan_date_start_d,
    dapan_date_end_d,
    dapan_cnt_d,
    arg_day_d,
    arg_open_d,
    arg_high_d,
    arg_low_d,
    arg_close_d,
    arg_vol_d,
    arg_money_d,
    rtn_idx_d,
    rtn_day_d,
    rtn_open_d,
    rtn_high_d,
    rtn_low_d,
    rtn_close_d,
    rtn_volume_d,
    rtn_money_d,
    rtn_cnt_dapan_d,
    rtn_cnt_d,
)
    index = (blockIdx().x - 1) * blockDim().x + threadIdx().x

    if index <= length(dapan_idx_d) #线程的数量多余任务的数量，防止越界

        #初始化
        rtn_idx_d[index] = dapan_idx_d[index]        #序号
        rtn_day_d[index] = dapan_date_end_d[index]   #周k线的日期
        rtn_cnt_dapan_d[index] = dapan_cnt_d[index]  #大盘在该周有几天交易日，用于跟rtn_cnt_d比对，看看个股在该周是否有停牌
        rtn_open_d[index] = -Inf      #开盘价    open = day_num == 1 的 open
        rtn_high_d[index] = -Inf      #最高价    取较大的值
        rtn_low_d[index] = Inf        #最低价    取较小的值
        rtn_close_d[index] = NaN      #收盘价    用当前close覆盖
        rtn_volume_d[index] = 0.0     #成交量    累加
        rtn_money_d[index] = 0.0      #成交资金  累加
        rtn_cnt_d[index] = 0          #交易日数  个股在每个周的交易日数量统计

        #遍历个股的数据，找到符合条件的，则进行处理
        for i = 1:length(arg_day_d)
            if dapan_date_start_d[index] <= arg_day_d[i] <= dapan_date_end_d[index]
                #交易日数量
                rtn_cnt_d[index] += 1

                #开盘价
                if rtn_cnt_d[index] == 1
                    rtn_open_d[index] = arg_open_d[i]
                end

                #最高价
                if arg_high_d[i] > rtn_high_d[index]
                    rtn_high_d[index] = arg_high_d[i]
                end

                #最低价
                if arg_low_d[i] < rtn_low_d[index]
                    rtn_low_d[index] = arg_low_d[i]
                end

                #收盘价，每天更新覆盖
                rtn_close_d[index] = arg_close_d[i]

                #成交量
                rtn_volume_d[index] += arg_vol_d[i]

                #成交资金
                rtn_money_d[index] += arg_money_d[i]
            end
        end
    else
        #
    end
    return nothing
end

3、计算时间对比

（1）用CPU计算周线的时间

一共4000多只个股，用单线程计算，耗时101秒

（2）用CUDA计算周线的时间

一共4000多只个股，用单线程计算，耗时11秒；用CPU多线程去调用核函数，耗时3秒。

（3）小技巧：如何在主存里面管理显存的变量？

下面代码功能：把GPU中的变量映射到内存中，用命名元组来管理

"""
在GPU中生成CuArray，用于缓存计算结果
"""
function gen_rtn_cu(N::Int64)
    return(
    idx = CUDA.ones(Int64,N),       #k线的序号
    day = CUDA.ones(Int64,N),       #日期
    open = CUDA.ones(Float64,N),    #开盘价
    high = CUDA.ones(Float64,N),    #最高价
    low = CUDA.ones(Float64,N),     #最低价
    close = CUDA.ones(Float64,N),   #收盘价
    volume = CUDA.ones(Float64,N),  #成交量
    money = CUDA.ones(Float64,N),   #成交额
    cnt_dapan = CUDA.ones(Int64,N), #本周大盘有多少个交易日
    cnt = CUDA.ones(Int64,N)        #本周个股有多少个交易日
    )
end

通过命名元组来获取GPU中的数组对象，并释放GPU空间

"""
释放gpu中的rtn_cu内存
"""
function free_rtn_cu(rtn)
    """
    如何编程自己循环捕捉对象，然后释放对象
    """
    rtn.idx |> CUDA.unsafe_free!       #k线的序号
    rtn.day |> CUDA.unsafe_free!       #日期
    rtn.open |> CUDA.unsafe_free!      #开盘价
    rtn.high |> CUDA.unsafe_free!      #最高价
    rtn.low |> CUDA.unsafe_free!       #最低价
    rtn.close |> CUDA.unsafe_free!     #收盘价
    rtn.volume |> CUDA.unsafe_free!    #成交量
    rtn.money |> CUDA.unsafe_free!     #成交额
    rtn.cnt_dapan |> CUDA.unsafe_free! #本周大盘有多少个交易日
    rtn.cnt |> CUDA.unsafe_free!       #本周个股有多少个交易日
    rtn = nothing

end

4、附录：代码

本文用到的k线数据是存于本地的，附录代码只供参考，不能直接运行。你可以用量化接口来读取数据，保存到本地，然后再进行实验。

（1）CPU计算的代码

#用CPU来生成k线，日线->周线,与GPU计算结果互相验证
using DataFrames
using DataFramesMeta
using CSV
using Dates
using BenchmarkTools


"""
用大盘的日k线，生成每周交易概要信息

输入：
df300 大盘的日k线

输出：
        k线序号         起始日期           结束日期           本周大盘交易日数量
DataFrame(idx = [...], date_start = [...], date_end = [...], cnt = [...])
"""
function gen_dapan_week_line_info(df300)
    #df300 |> display
    df300.week = df300.day .|> week

    #把week逐个计数,相同的week，它的idx相同
    df300.weekidx = let
        last_week = 0
        idx = 1
        idx_ary = []
        for (i, r) in zip(1:size(df300, 1), eachrow(df300))
            if i == 1
                idx = 1
                last_week = r.week
            elseif i > 1
                if last_week != r.week
                    idx += 1
                    last_week = r.week
                else
                    last_week = r.week
                end
            end
            push!(idx_ary, idx)
        end
        idx_ary
    end


    #生成周k线中每根k线的概要信息，用于计算详细的k线
    info_df = DataFrame(idx = [], date_start = [], date_end = [], cnt = [])
    gd = groupby(df300, "weekidx")

    for weekidx in df300.weekidx |> unique |> sort
        #println(weekidx)
        sub_df = gd[weekidx] |> df -> sort(df, "day")
        idx = weekidx
        sub_df = gd[weekidx] |> df -> sort(df, "day")
        date_start = first(sub_df, 1)[1, "day"]
        date_end = last(sub_df, 1)[1, "day"]
        cnt = size(sub_df, 1)

        push!(info_df, [idx, date_start, date_end, cnt])
    end

    return info_df
end

function  gen_dapan_week_line_info_test()
    df300 = CSV.read("data/399300.csv",DataFrame)
    df300 |> display
    info_df = gen_dapan_week_line_info(df300)
    info_df |> display
end

gen_dapan_week_line_info_test()

"""
帮个股生成周k线

输入：
info_df  大盘每周交易日信息
df       个股日k线

输出：
DataFrame
          序号        日期        开盘价       最高价        最低价      收盘价         成交量        成交金额        本周大盘交易日数量 本周个股交易日数量
--------------------------------------------------------------------------------------------------------------------------------------------------------
DataFrame(idx = [...],day = [...],open = [...],high = [...],low = [...],close = [...],volume = [...],money = [...],dapan_cnt=[...],cnt = [...])
"""
function gen_weekly_kline(info_df,df)
    rtn_df = DataFrame(idx = [],day = [],open = [],high = [],low = [],close = [],volume = [],money = [],dapan_cnt=[],cnt = [])

    for r in eachrow(info_df)
        idx = r.idx
        date_start = r.date_start
        date_end = r.date_end

        q_df = @linq df |> where(date_start .<= :day .<= date_end)
        if size(q_df,1) > 0
            sort!(q_df,"day")

            day = date_end
            open = q_df.open[1]
            high = q_df.high |> maximum
            low = q_df.low |> minimum
            close = q_df.close[end]
            volume = q_df.vol |> sum
            money = q_df.money |> sum
            dapan_cnt = r.cnt
            cnt = size(q_df,1)

            push!(rtn_df,[idx,day,open,high,low,close,volume,money,dapan_cnt,cnt])
        else  #本周个股停牌
            day = date_end
            open = 0.0
            high = 0.0
            low = 0.0
            close = 0.0
            volume = 0.0
            money = 0.0
            dapan_cnt = r.cnt
            cnt = 0
            push!(rtn_df,[idx,day,open,high,low,close,volume,money,dapan_cnt,cnt])
        end
    end
    rtn_df
end

function gen_weekly_kline_test()
    #读取大盘数据
    df300 = CSV.read("data/399300.csv",DataFrame)
    df300 |> display
    info_df = gen_dapan_week_line_info(df300)
    info_df |> display

    #读取个股信息
    df = CSV.read("data/股票/000001.csv",DataFrame)
    gen_weekly_kline(info_df,df)
end

gen_weekly_kline_test()

#读取所有的股票
stocks = readdir("data/股票") .|> item->split(item,".")[1]

"""
读取所有的股票k线，存到一个字典中备用
"""
function get_stocks_dict(stocks)
    mydict = Dict()
    for s in stocks
        mydict[s] = CSV.read("data/股票/$(s).csv",DataFrame)
    end
    mydict
end

stocks_dict = get_stocks_dict(stocks)

"""
计算多只个股的周线表
"""
function main_multi_stocks(stocks_dict)
    #读取大盘数据
    df300 = CSV.read("data/399300.csv",DataFrame)
    #df300 |> display
    info_df = gen_dapan_week_line_info(df300)
    #info_df |> display

    t1 = time()
    #逐只个股计算
    for (stock,df) in stocks_dict
        week_df = gen_weekly_kline(info_df,df)
        CSV.write("data/cpu周线/$(stock).csv",week_df)
    end
    t2 = time()

    println(t2-t1)
end

main_multi_stocks(stocks_dict)

#单线程 101s

（2）GPU计算的代码

#用GPU来生成k线，日线->周线
using DataFrames
using CSV
using XLSX
using Dates

using BenchmarkTools
using CUDA
using Test

if capability(device()) < v"7.0"
    println("你的显卡计算能力没达到7.0，退出程序！！")
    exit()
end


"""
【月份】和【日期】字符串格式化为两位
01 =  01
1  =  01

输入:"0"-"31" 或者 "00"-"31"
"""
function format_str_00(str::String)
    rtn = ""
    if length(str) == 1
        rtn = string(0,str)
    else
        rtn = str
    end
    return rtn
end

format_str_00("9")
format_str_00("12")


"""
把一个Date日期转成同形式字面量的Int,注意，月份和日期会补足成两位
例如:
__________________________
      Date   => Int64
==========================
"2021-01-09" => 20210109
==========================
"""
function get_int_day(mydate::Date)
    day_str = ""
    y = string(mydate |> year)
    m = string(mydate |> month) |> format_str_00
    d = string(mydate |> day) |> format_str_00
    parse(Int64, string(y, m, d))
    return parse(Int64, string(y, m, d))
end

get_int_day(Date("2021-01-09"))
get_int_day(Date("2021-2-1"))
get_int_day(Date("2021-12-14"))


"""
从日k线中，生成每根周线k线的【起始日期】和【终止日期】信息。作用：【个股日线生成周线的时候，用这两个日期，进行检索】

==输出==
     |序号  开始日期    结束日期   交易天数
Row  │ idx  date_start  date_end  cnt
     │ Any  Any         Any       Any
─────┼────────────────────────────────
   1 │ 1    20091203    20091204  2
   2 │ 2    20091207    20091211  5
   3 │ 3    20091214    20091218  5
   4 │ 4    20091221    20091225  5
   ⋮  │  ⋮       ⋮          ⋮       ⋮
 562 │ 562  20201116    20201120  5
 563 │ 563  20201123    20201127  5
 564 │ 564  20201130    20201202  3

"""
function gen_week_kline_info(df300)
    df = DataFrame(idx = [],date_start = [],date_end = [],cnt = [])
    idx = 0                 #每根k线的序号
    date_start = 19700101   #起始日期【用int来存储日期】
    date_end = 19700101     #结束日期
    cnt = 0                 #本周交易日的天数

    last_week = -1          #上一根k线的week值，计算周线的时候，week跳变是标志事件
    for i in 1:size(df300,1)
        current_week = df300[i,"week"]
        if current_week != last_week  #新的一周开始了
            #把上一周的信息假如到df中
            if idx > 0
                date_end = df300[i-1,"day"] |> get_int_day
                push!(df,[idx,date_start,date_end,cnt])
            end

            #新的一周的计数
            date_start = df300[i,"day"] |> get_int_day
            idx += 1
            cnt = 1
        else                        #同一个周
            cnt += 1
        end

        last_week = current_week

        if i == size(df300,1) #最后在生成一根k线
            date_end = df300[i,"day"] |> get_int_day
            push!(df,[idx,date_start,date_end,cnt])
        end
    end
    df
end

function gen_week_kline_info_test()
    #读取hs300大盘数据
    df300 = CSV.read("data/399300.csv",DataFrame)
    df300 |> display

    #计算week
    df300[!,"week"] = df300.day .|> week
    kline_info = gen_week_kline_info(df300)
    kline_info |> display
end

gen_week_kline_info_test()

"""
在GPU中生成大盘周线的概要信息

输入：
kline_info   周k线的概要信息df

输出：
命名元组：
(
idx = CuArray(kline_info.idx .|> Int64),               #序号
start_date = CuArray(kline_info.date_start .|> Int64), #开始日期
end_date =  CuArray(kline_info.date_end .|> Int64),    #结束日期
cnt = CuArray(kline_info.cnt .|> Int64)                #本周交易日天数
)

"""
function gen_cu_dapan_kline_info(kline_info)
    return(
    idx = CuArray(kline_info.idx .|> Int64),               #序号
    start_date = CuArray(kline_info.date_start .|> Int64), #开始日期
    end_date =  CuArray(kline_info.date_end .|> Int64),    #结束日期
    cnt = CuArray(kline_info.cnt .|> Int64)                #本周交易日天数
    )
end

"""
释放cu_dapan_kline_info在GPU上的内存
"""
function free_cu_dapan_kline_info(cu_info)
    cu_info.idx |> CUDA.unsafe_free!         #序号
    cu_info.start_date |> CUDA.unsafe_free!  #开始日期
    cu_info.end_date |> CUDA.unsafe_free!    #结束日期
    cu_info.cnt |> CUDA.unsafe_free!         #本周交易日天数

    cu_info = nothing
end

function gen_cu_dapan_kline_info_test()
    #读取日k线数据
    df300 = CSV.read("data/399300.csv",DataFrame)
    df300 |> display

    #计算week
    df300[!,"week"] = df300.day .|> week

    #生成k线概要信息
    kline_info = gen_week_kline_info(df300)
    kline_info |> display

    #在gpu中生成k线概要信息
    dapan_cu = gen_cu_dapan_kline_info(kline_info)
    dapan_cu |> display

    dapan_cu.idx |> typeof |> display

    dapan_cu
    free_cu_dapan_kline_info(dapan_cu)

    try
        dapan_cu.idx |> display
    catch e

        println("执行代码[dapan_cu.idx |> display] 出错，info = ",e)
    end

end

gen_cu_dapan_kline_info_test()

"""
在GPU中生成CuArray，用于缓存计算结果
"""
function gen_rtn_cu(N::Int64)
    return(
    idx = CUDA.ones(Int64,N),       #k线的序号
    day = CUDA.ones(Int64,N),       #日期
    open = CUDA.ones(Float64,N),    #开盘价
    high = CUDA.ones(Float64,N),    #最高价
    low = CUDA.ones(Float64,N),     #最低价
    close = CUDA.ones(Float64,N),   #收盘价
    volume = CUDA.ones(Float64,N),  #成交量
    money = CUDA.ones(Float64,N),   #成交额
    cnt_dapan = CUDA.ones(Int64,N), #本周大盘有多少个交易日
    cnt = CUDA.ones(Int64,N)        #本周个股有多少个交易日
    )
end

"""
释放gpu中的rtn_cu内存
"""
function free_rtn_cu(rtn)
    """
    如何编程自己循环捕捉对象，然后释放对象
    """
    rtn.idx |> CUDA.unsafe_free!       #k线的序号
    rtn.day |> CUDA.unsafe_free!       #日期
    rtn.open |> CUDA.unsafe_free!      #开盘价
    rtn.high |> CUDA.unsafe_free!      #最高价
    rtn.low |> CUDA.unsafe_free!       #最低价
    rtn.close |> CUDA.unsafe_free!     #收盘价
    rtn.volume |> CUDA.unsafe_free!    #成交量
    rtn.money |> CUDA.unsafe_free!     #成交额
    rtn.cnt_dapan |> CUDA.unsafe_free! #本周大盘有多少个交易日
    rtn.cnt |> CUDA.unsafe_free!       #本周个股有多少个交易日
    rtn = nothing

end

function gen_rtn_cu_test()
    #生成第一个rtn
    res1 = gen_rtn_cu(1024)
    res1.idx .+= 1
    res1.idx |> display

    #生成第二个rtn
    res2 = gen_rtn_cu(1024)
    res2.idx |> display

    #释放对象并测试
    free_rtn_cu(res1)
    try
        res1.idx |> println
    catch
        println("执行代码：res1.idx |> println ，因为res1已经销毁了！")
    end
end

gen_rtn_cu_test()


"""
把k线的数据载入到GPU中
====输入====
df k线数据df
====输出===
命名元组
(
day = CuArray(df.day .|> get_int_day)  #k线的日期
open = CuArray(df.open)    #开盘价
high = CuArray(df.high)    #最高价
low = CuArray(df.low)      #最低价
close = CuArray(df.close)  #收盘价
vol = CuArray(df.vol)      #成交量
money = CuArray(df.money)  #成交额
)

"""
function gen_cu_stock_kline(df)
    return(
    day = CuArray(df.day .|> get_int_day),  #k线的日期
    open = CuArray(df.open),    #开盘价
    high = CuArray(df.high),    #最高价
    low = CuArray(df.low),      #最低价
    close = CuArray(df.close),  #收盘价
    vol = CuArray(df.vol),      #成交量
    money = CuArray(df.money)  #成交额
    )
end

"""
释放cu_stock_kline对象在GPU上的内存
"""
function free_cu_stock_kline(stock_cu)
    stock_cu.day |> CUDA.unsafe_free!    #k线的日期
    stock_cu.open |> CUDA.unsafe_free!   #开盘价
    stock_cu.high |> CUDA.unsafe_free!   #最高价
    stock_cu.low |> CUDA.unsafe_free!    #最低价
    stock_cu.close |> CUDA.unsafe_free!  #收盘价
    stock_cu.vol |> CUDA.unsafe_free!    #成交量
    stock_cu.money |> CUDA.unsafe_free!  #成交额
    stock_cu = nothing
end

function gen_cu_stock_kline_test()
    df = CSV.read("data/股票/000001.csv",DataFrame)
    stock_cu = gen_cu_stock_kline(df)

    stock_cu.open |> display

    free_cu_stock_kline(stock_cu)
    try
        stock_cu.day |> display
    catch e
        println("执行代码【stock_cu.day |> display】出错",e)
    end

end

gen_cu_stock_kline_test()



"""
GPU核函数：生成周k线

dapan_idx_d,
dapan_date_start_d,
dapan_date_end_d,
dapan_cnt_d,

arg_day_d,
arg_open_d,
arg_high_d,
arg_low_d,
arg_close_d,
arg_vol_d,
arg_money_d,

rtn_idx_d,
rtn_day_d,
rtn_open_d,
rtn_high_d,
rtn_low_d,
rtn_close_d,
rtn_volume_d,
rtn_money_d,
rtn_cnt_dapan_d,
rtn_cnt_d,
"""
function gen_weekly_kline_kernel!(
    dapan_idx_d,
    dapan_date_start_d,
    dapan_date_end_d,
    dapan_cnt_d,
    arg_day_d,
    arg_open_d,
    arg_high_d,
    arg_low_d,
    arg_close_d,
    arg_vol_d,
    arg_money_d,
    rtn_idx_d,
    rtn_day_d,
    rtn_open_d,
    rtn_high_d,
    rtn_low_d,
    rtn_close_d,
    rtn_volume_d,
    rtn_money_d,
    rtn_cnt_dapan_d,
    rtn_cnt_d,
)
    index = (blockIdx().x - 1) * blockDim().x + threadIdx().x

    if index <= length(dapan_idx_d) #线程的数量多余任务的数量，防止越界

        #初始化
        rtn_idx_d[index] = dapan_idx_d[index]        #序号
        rtn_day_d[index] = dapan_date_end_d[index]   #周k线的日期
        rtn_cnt_dapan_d[index] = dapan_cnt_d[index]  #大盘在该周有几天交易日，用于跟rtn_cnt_d比对，看看个股在该周是否有停牌
        rtn_open_d[index] = -Inf      #开盘价    open = day_num == 1 的 open
        rtn_high_d[index] = -Inf      #最高价    取较大的值
        rtn_low_d[index] = Inf        #最低价    取较小的值
        rtn_close_d[index] = NaN      #收盘价    用当前close覆盖
        rtn_volume_d[index] = 0.0     #成交量    累加
        rtn_money_d[index] = 0.0      #成交资金  累加
        rtn_cnt_d[index] = 0          #交易日数  个股在每个周的交易日数量统计

        #遍历个股的数据，找到符合条件的，则进行处理
        for i = 1:length(arg_day_d)
            if dapan_date_start_d[index] <= arg_day_d[i] <= dapan_date_end_d[index]
                #交易日数量
                rtn_cnt_d[index] += 1

                #开盘价
                if rtn_cnt_d[index] == 1
                    rtn_open_d[index] = arg_open_d[i]
                end

                #最高价
                if arg_high_d[i] > rtn_high_d[index]
                    rtn_high_d[index] = arg_high_d[i]
                end

                #最低价
                if arg_low_d[i] < rtn_low_d[index]
                    rtn_low_d[index] = arg_low_d[i]
                end

                #收盘价，每天更新覆盖
                rtn_close_d[index] = arg_close_d[i]

                #成交量
                rtn_volume_d[index] += arg_vol_d[i]

                #成交资金
                rtn_money_d[index] += arg_money_d[i]
            end
        end
    else
        #
    end
    return nothing
end


"""
把GPU中的rtn复制到host中，组成一个df
"""
function gen_df_from_gpu(rtn_cu)
    #从GPU复制数据
    idx = rtn_cu.idx |> Array
    day = rtn_cu.day |> Array
    open = rtn_cu.open |> Array
    high = rtn_cu.high |> Array
    low = rtn_cu.low |> Array
    close = rtn_cu.close |> Array
    volume = rtn_cu.volume |> Array
    money = rtn_cu.money |> Array
    dapan_cnt = rtn_cu.cnt_dapan |> Array
    cnt = rtn_cu.cnt |> Array

    df = DataFrame(idx = idx,day = day,open = open,high = high,low = low,close = close,volume = volume,money = money,dapan_cnt=dapan_cnt,cnt = cnt)
end


function main2(stocks_dict)
    #加载大盘数据
    df300 = CSV.read("data/399300.csv", DataFrame)
    df300[!, "week"] = df300.day .|> week

    #生成k线概要信息
    dapan_kline_info = gen_week_kline_info(df300)

    #在gpu中生成k线概要信息
    dapan_cu = gen_cu_dapan_kline_info(dapan_kline_info)

    #free_cu_dapan_kline_info(dapan_cu)

    t1 = time()

    #Threads.@threads for stock in stocks_dict |> keys |> collect
    for stock in stocks_dict |> keys |> collect
        df = stocks_dict[stock]
        #println(stock)
        stock_cu = gen_cu_stock_kline(df)

        N = size(dapan_kline_info, 1)
        rtn_cu = gen_rtn_cu(N)

        #启动CUDA内核进行计算
        numblocks = ceil(Int, N / 256)
        CUDA.@sync begin
            @cuda threads = 256 blocks = numblocks gen_weekly_kline_kernel!(
                dapan_cu.idx,
                dapan_cu.start_date,
                dapan_cu.end_date,
                dapan_cu.cnt,
                stock_cu.day,
                stock_cu.open,
                stock_cu.high,
                stock_cu.low,
                stock_cu.close,
                stock_cu.vol,
                stock_cu.money,
                rtn_cu.idx,
                rtn_cu.day,
                rtn_cu.open,
                rtn_cu.high,
                rtn_cu.low,
                rtn_cu.close,
                rtn_cu.volume,
                rtn_cu.money,
                rtn_cu.cnt_dapan,
                rtn_cu.cnt,
            )

            #从GPU上获取数据
            df = gen_df_from_gpu(rtn_cu)
            #CSV.write("data/gpu周线/$(stock).csv", df)

            #清空gpu变量
            #free_cu_dapan_kline_info(dapan_cu)
            free_cu_stock_kline(stock_cu)
            free_rtn_cu(rtn_cu)
        end
    end

    t2 = time()

    println(t2 - t1)

end

#读取所有的股票
stocks = readdir("data/股票") .|> item->split(item,".")[1]

"""
读取所有的股票k线，存到一个字典中备用
"""
function get_stocks_dict(stocks)
    mydict = Dict()
    for s in stocks
        mydict[s] = CSV.read("data/股票/$(s).csv",DataFrame)
    end
    mydict
end

stocks_dict = get_stocks_dict(stocks)

main2(stocks_dict)