Exemple #1
0
 def test_profiler_measure_empty_program(self):
     cost_model = core.CostModel()
     empty_program = paddle.static.Program()
     startup_program = paddle.static.Program()
     cost_data = cost_model.profile_measure(empty_program, startup_program,
                                            device, ["time"])
     self.assertEqual(cost_data.get_whole_time_ms(), 0)
Exemple #2
0
    def profile_measure(self,
                        startup_program,
                        main_program,
                        device='gpu',
                        fetch_cost_list=['time']):

        place = paddle.set_device('gpu')
        x = np.random.random(size=(10, 1)).astype('float32')
        exe = paddle.static.Executor(place)

        exe.run(startup_program)
        paddle.fluid.profiler.start_profiler("All")
        exe.run(main_program, feed={"X": x}, fetch_list=[])

        cost_model = core.CostModel()
        cost_data = cost_model.ProfileMeasure(device)
Exemple #3
0
 def test_profiler_measure_program(self):
     main_program = paddle.static.Program()
     startup_program = paddle.static.Program()
     with paddle.static.program_guard(main_program, startup_program):
         # TODO(zhhsplendid): support paddle.static.data, which is uninitialized data
         data = paddle.ones(name='X', shape=[16, 100], dtype='float32')
         hidden = paddle.static.nn.fc(data, 10)
         loss = paddle.mean(hidden)
     cost_model = core.CostModel()
     cost_data = cost_model.profile_measure(main_program, startup_program,
                                            device, ["time"])
     fc_op_time = cost_data.get_op_time_ms(0)
     mean_op_time = cost_data.get_op_time_ms(1)
     self.assertGreater(fc_op_time, 0)
     self.assertGreater(mean_op_time, 0)
     self.assertGreaterEqual(cost_data.get_whole_time_ms(),
                             fc_op_time + mean_op_time)
Exemple #4
0
def get_single_node_data():
    train_program = paddle.static.Program()
    startup_program = paddle.static.Program()

    loss, train_program, startup_program = mlp_forward(train_program,
                                                       startup_program,
                                                       is_distributed=False)

    cost_model = core.CostModel()
    cost_data = cost_model.profile_measure(train_program, startup_program,
                                           device, ["time"])

    op_name2cost = [{}, {}]
    for idx, op in enumerate(train_program.blocks[0].ops):
        if idx <= STAGE_0_CNT:
            op_name2cost[0][op.type] = cost_data.get_op_time_ms(idx)
        elif idx <= STAGE_1_CNT:
            op_name2cost[1][op.type] = cost_data.get_op_time_ms(idx)
    return op_name2cost