I wrote a demo tensorflow code, and graph is the same as that of pytorch.
On same machine.
tensorflow 0.12
the timing info is:
batch duration: 0.0545980930328 s
training speed: 1831.56580102/sec
here is the code:

import time
import tensorflow as tf
import numpy as np



with tf.Graph().as_default():
    max_text_len = 50
    num_classes = 10
    vocab_size = 62639
    emb_dim = 300
    num_train_instances = 20000
    num_test_instances = 2000
    train_batch_size = 100
    test_batch_size = 100



    # model part
    filter_size = 3
    num_filters = 200



    # generating random data
    seed = 1234
    rng = np.random.RandomState(seed)
    train_set = rng.randint(0, vocab_size, (num_train_instances, max_text_len)), rng.randint(0, num_classes, (num_train_instances))
    test_set = rng.randint(0, vocab_size, (num_test_instances, max_text_len)), rng.randint(0, num_classes, (num_test_instances))
    n_train_batch = train_batch_size / train_batch_size + 1
    n_test_batch = test_batch_size / test_batch_size + 1



    def get_batch(source, i, batch_size):
        data = source[0][i * batch_size: (i + 1) * batch_size]
        target = source[1][i * batch_size: (i + 1) * batch_size]
        return data, target



    #  describe graph
    input_x = tf.placeholder(tf.int32, [None, max_text_len], name="input_x")
    input_y = tf.placeholder(tf.int32, [None], name="input_y")
    with tf.device('/cpu:0'), tf.name_scope("embedding"):
        emb_w = tf.Variable(tf.random_uniform([vocab_size, emb_dim], -1.0, 1.0), name="emb_w")
        embedded = tf.nn.embedding_lookup(emb_w, input_x)
        embedded_expanded = tf.expand_dims(embedded, -1)



    with tf.name_scope("conv-maxpool-%s" % filter_size):
        filter_shape = [filter_size, emb_dim, 1, num_filters]
        W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")
        b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b")
        conv = tf.nn.conv2d(
            embedded_expanded,
            W,
            strides=[1, 1, 1, 1],
            padding="VALID",
            name="conv")
        # Apply nonlinearity
        h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")
        # Maxpooling over the outputs
        pooled = tf.nn.max_pool(
            h,
            ksize=[1, max_text_len - filter_size + 1, 1, 1],
            strides=[1, 1, 1, 1],
            padding='VALID',
            name="pool")
        h_pool_flat = tf.reshape(pooled, [-1, num_filters])
    with tf.name_scope("dropout"):
        h_drop = tf.nn.dropout(h_pool_flat, 0.5)



    with tf.name_scope("hidden"):
        W = tf.get_variable(
            "h_W",
            shape=[num_filters, num_filters],
            initializer=tf.contrib.layers.xavier_initializer())
        b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b")
        hidden_out = tf.nn.xw_plus_b(h_drop, W, b, name="hidden_out")



    with tf.name_scope("output"):
        W = tf.get_variable(
            "o_W",
            shape=[num_filters, num_classes],
            initializer=tf.contrib.layers.xavier_initializer())
        b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")
        scores = tf.nn.xw_plus_b(hidden_out, W, b, name="scores")
    with tf.name_scope("loss"):
        losses = tf.nn.sparse_softmax_cross_entropy_with_logits(scores, input_y)



# training
    session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)
    sess = tf.Session(config=session_conf)



    optimizer = tf.train.AdamOptimizer(1e-3)
    grads_and_vars = optimizer.compute_gradients(losses)
    train_op = optimizer.apply_gradients(grads_and_vars)
    sess.run(tf.global_variables_initializer())



    for epoch in xrange(10):



        for i in xrange(n_train_batch):
            start_time = time.time()
            x_batch, y_batch = get_batch(train_set, i, train_batch_size)
            print x_batch.shape
            print y_batch.shape
            feed_dict = {
                input_x: x_batch,
                input_y: y_batch,
            }
            _, loss_ = sess.run([train_op, losses], feed_dict)
            duration = time.time() - start_time
            print "duration: {} s".format(duration)
            print "speed: {}/sec".format(train_batch_size / duration)


Thank you very much!