Why does writing to memory take longer than reading in GPU? - optimization

Question

Here is part of my code where I update some values and write it to another part of my memory
__kernel void update(
__global float4 *f,
__global float4 *p,
const unsigned int n,
__local float4 *sharedP){
float4 val = (float4)(0.f,0.f,0.f,0.f);
size_t lID = get_local_id(0);
size_t gID = get_global_id(0);
if(gID < n){
float4 p1 = p[gID];
for(size_t i = 0; i < n; ++i){
if(i!=gID){
float4 p2 = p1 - p[i];
//Some other calculations to finally update 'val'
}
}
f[gID] = val;
}
}
Here each thread reads from the global memory n+1 times, but writes back only once.(My initial thought was that, the bottleneck was due repeated call to the global memory, hence I had made some changes to copy a block of data into the shared memory, swap it and other things. Even this did not improve the performance a lot). However later I found that the bottleneck is due to f[gID] = val;. For example when the kernel is run 200 times with n = 8192, it takes 3.5s; but if I comment out f[gID] = val; it takes only 0.05s.
Code for other method
__kernel void update(
__global float4 *f,
__global float4 *p,
const unsigned int n,
__local float4 *sharedP){
float4 val = (float4)(0.f,0.f,0.f,0.f);
size_t lID = get_local_id(0);
size_t gID = get_global_id(0);
if(gID < n){
sharedP[lID] = p[gID];
barrier(CLK_LOCAL_MEM_FENCE);
float4 p1 = sharedP[lID];
//To prevent i!=gID of other method
for(size_t i = 0; i < get_local_size(0);; ++i){
if(lID!=i){
float4 p2 = p1 - sharedP[i];
//Some other calculations to update 'val' at 0
}
}
for(size_t block = 1; block < (size_t)(get_global_size(0)/get_local_size(0)); ++block){
size_t idx = lID + (get_group_id(0) + block ) * get_local_size(0);
if( idx >= n)
idx -= n;
sharedP[lID] = p[idx];
barrier(CLK_LOCAL_MEM_FENCE);
for(size_t i = 0; i < get_local_size(0); ++i){
float4 p = p1 - sharedP[i];
//Some other calculations to update 'val'
}
f[gID] = val;
}
}
}
So how is writing to memory causing it to slow down so much and why is using shared memory not providing a significant performance increase?