如何把英伟达显卡驱动安装在非系统盘_百度知道
如何把英伟达显卡驱动安装在非系统盘
我有更好的答案
安装的时候选择目标盘的目标位置，不过这个驱动通常是不需要改变的，我建议你还是装在系统盘里，要不然你下次重装系统之后那个显卡驱动还是在非系统盘里占用你的空间，并且嵌入新系统
采纳率：29%
来自团队：
为何要安装再其他磁盘？费解一般驱动是默认安装到系统盘，用 软件搬家
显卡驱动智能安装在系统盘。8过你可以试试安装好之后用360的C盘搬家功能看看能不能把它移走。
显卡驱动智能安装在系统盘
不可以，驱动必须安装在系统盘下
其他2条回答
为您推荐：
其他类似问题
显卡驱动的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。建立GPU开发环境 - 为程序员服务
建立GPU开发环境
建立GPU开发环境
手里有一个 Alienware 笔记本电脑，外加几本 CUDA 开发的书籍，打算学习下 GPU 开发方面的知识。
看看了Macbook Pro使用的是 Intel显卡 ，因此只能使用 仿真方式 运行CUDA程序了，但可以使用 OpenCL 程序，毕竟苹果提出的OpenCL。
又跑到Alienware笔记本上装Fedora系统，发现折腾无线网卡驱动失败，就换了Ubuntu，又发现没有Nvidia显卡而失败。
然后切换到Win8系统，提醒说要更新Nvidia驱动，心想，这是有Nvidia显卡啊。
于是，删掉所有数据，重新安装了一个Ubuntu，系统装到SSD磁盘上，另外一个三星磁盘用来存数据。
Ubuntu毕竟是桌面化做的比较好，一路还算顺利，但也折腾了几个小时；接下来，可以用CUDA C写写程序，也可以用PyCUDA，当然也不能忘了OpenCL。
2 为Ubuntu激活无线网络
不知道为什么，每次安装好Linux，几乎总是遇到无线网络的问题，烦不甚烦！
自己安装的是Ubuntu 14.04LTS版本，来源:
2.1 重新安装b43相关全部驱动和firmware
$ sudo apt-get install bcmwl-kernel-source
#Broadcom 802.11 Linux STA 无线驱动源
$ sudo apt-get install broadcom-sta-common
$ sudo apt-get install broadcom-sta-source
$ sudo apt-get install b43-fwcutter
#Broadcom 43xx 固件提取工具
$ sudo apt-get install firmware-b43-installer
2.2 激活无线网卡
$ sudo modprobe -r b43 ssb
$ sudo modprobe b43
2.3 开机自动激活
加入文件/etc/rc.local中:
$ sudo modprobe b43
3 为Linux添加磁盘
由于安装系统的时候将系统数据直接弄到那块SSD磁盘上，需要将另外那块三星磁盘添加到系统，来源:
3.1 找到设备文件
$ sudo fdisk -l
发现在使用的是 /dev/sdb ，另一个没有使用的是 /dev/sda
3.2 为磁盘分区
$ sudo fdisk /etc/sdba
按 m 获取帮助信息，按 n 创建新分区，选择 p 表示主分区，使用 1 作为主分区编号。
由于我没有打算弄太复杂，过几天说不定再重装一遍呢。按 w 写入修改退出，则有了设备文件 /dev/sda1
3.3 格式化磁盘
$ sudo mkfs -t ext4 /dev/sda1
3.4 挂载该分区
$ sudo mkdir /Yi
$ sudo mount /dev/sda1 /Yi
$ sudo chmod -R g+w /Yi
同时为了开机自动挂载，在文件/etc/fstab中加入:
4 安装Nvidia驱动
跑到Nvidia官网下载驱动文件，结果安装过程还挺复杂，来源:
在这个过程的记得常做 sudo apt-get update 和重启以便生效。
4.1 下载驱动文件
到Nvidia官网下载对应平台、对应显卡型号的驱动文件(.run)
4.2 安装编译依赖
$ sudo apt-get install build-essential pkg-config xserver-xorg-dev linux-headers-`uname -r`
4.3 屏蔽开源驱动nouveau
驱动之间存在冲突，为了避免，在/etc/modprobe.d/blacklist.conf加入:
blacklist vga16fb
blacklist nouveau
blacklist rivafb
blacklist nvidiafb
blacklist rivatv
4.4 关闭图形环境
$ sudo stop lightdm
4.5 在tty控制台安装驱动
关闭图形环境后，按键Ctrl+Alt+F2可以跳到第一个终端控制台，以终端模式登陆后:
$ cd /home/username
$ sudo bash NVIDIA*.run
安装过程中:
提示有旧驱动，询问是否删除旧驱动，选Yes
提示缺少模块，循环是否上网下载，选No
提示编译模块，询问是否编译，选Yes
提示要修改Xorg.conf，询问是否允许，选Yes
4.6 启动图形环境
$ sudo start lightdm
4.7 其他：卸载旧驱动
$ sudo apt-get --purge remove nvidia-*
$ sudo apt-get --purge remove xserver-xorg-video-nouveau
4.8 重启生效
重启后可能要重新安装驱动，安装驱动后可能显示的分辨率等都要重新设置。
5 分辨率错误
这中间过程由于下载了几个版本的驱动，也不知道怎么回事就改写了xorg配置文件，导致分辨率出现问题, 一阵折腾.
如果只是由于Nvidia修改了 xorg.conf 文件，可以使用 nvidia-uninstall 恢复，或者用 Xorg -configure 生成默认配置文件。
用Xorg恢复默认配置后，就发现登陆后就能看到鼠标和桌面，其他状态栏等都看不到，彻底废了。
东查西找，搞了半天是 Ubuntu 14.04 存在一个所谓的 Unity冻结 问题，这种版本也能出来，真是服了，除了重装还能期待什么?!
6 试试CUDA程序
// This is the REAL "hello world" for CUDA!
// It takes the string "Hello ", prints it, then passes it to CUDA with an array
// of offsets. Then the offsets are added in parallel to produce the string "World!"
// By Ingemar Ragnemalm 2010
#include &stdio.h&
const int N = 16;
const int blocksize = 16;
__global__
void hello(char *a, int *b)
a[threadIdx.x] += b[threadIdx.x];
int main()
char a[N] = "Hello \0\0\0\0\0\0";
int b[N] = {15, 10, 6, 0, -11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const int csize = N*sizeof(char);
const int isize = N*sizeof(int);
printf("%s", a);
cudaMalloc( (void**)&ad, csize );
cudaMalloc( (void**)&bd, isize );
cudaMemcpy( ad, a, csize, cudaMemcpyHostToDevice );
cudaMemcpy( bd, b, isize, cudaMemcpyHostToDevice );
dim3 dimBlock( blocksize, 1 );
dim3 dimGrid( 1, 1 );
hello&&&dimGrid, dimBlock&&&(ad, bd);
cudaMemcpy( a, ad, csize, cudaMemcpyDeviceToHost );
cudaFree( ad );
cudaFree( bd );
printf("%s\n", a);
return EXIT_SUCCESS;
$ nvcc source.cu
7 试试OpenCL程序
// Hello World for OpenCL - the real thing!
// Like my CUDA Hello World, it computes, in parallel, on the GPU,
// the string "World!" from "Hello " and an array of offsets.
// By Ingemar Ragnemalm, based on the hello.c demo.
// Updated 2013 for newer OpenCL versions and #ifdef for Linux
#include &stdio.h&
#include &math.h&
#ifdef __APPLE__
#include &OpenCL/opencl.h&
#include &CL/cl.h&
const char *KernelSource = "\n" \
"__kernel void hello(
__global char* a,
__global char* b,
__global char* c,
const unsigned int count)
int i = get_global_id(0);
if(i & count)
c[i] = a[i] + b[i];
#define DATA_SIZE (16)
int main(int argc, char** argv)
// error code returned from api calls
cl_device_id device_ // compute device id
cl_ // compute context
cl_command_
// compute command queue
// compute program
// compute kernel
// device memory used for the input array
cl_mem input2;
// device memory used for the input array
// device memory used for the output array
// global domain size for our calculation
// local domain size for our calculation
unsigned int count = DATA_SIZE;
// Input data
char a[DATA_SIZE] = "Hello \0\0\0\0\0\0";
char b[DATA_SIZE] = {15, 10, 6, 0, -11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
// Output data
char c[DATA_SIZE];
// Print original data
printf("%s", a);
cl_platform_
unsigned int no_
clGetPlatformIDs(1,&platform,&no_plat);
// Where to run
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
if (err != CL_SUCCESS) return -1;
context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!context) return -1;
commands = clCreateCommandQueue(context, device_id, 0, &err);
if (!commands) return -1;
// What to run
program = clCreateProgramWithSource(context, 1, (const char **) & KernelSource, NULL, &err);
if (!program) return -1;
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS) return -1;
kernel = clCreateKernel(program, "hello", &err);
if (!kernel || err != CL_SUCCESS) return -1;
// Create space for data and copy a and b to device (note that we could also use clEnqueueWriteBuffer to upload)
input = clCreateBuffer(context,
CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
sizeof(char) * DATA_SIZE, a, NULL);
input2 = clCreateBuffer(context,
CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
sizeof(char) * DATA_SIZE, b, NULL);
output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(char) * DATA_SIZE, NULL, NULL);
if (!input || !output) return -1;
// Send data
= clSetKernelArg(kernel, 0, sizeof(cl_mem), &input);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &input2);
err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &output);
err |= clSetKernelArg(kernel, 3, sizeof(unsigned int), &count);
if (err != CL_SUCCESS) return -1;
local = DATA_SIZE;
// Run kernel!
global = DATA_SIZE; //
err = clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL);
if (err != CL_SUCCESS) return -1;
clFinish(commands);
// Read result
err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(char) * count, c, 0, NULL, NULL );
if (err != CL_SUCCESS) return -1;
//Print result
printf("%s\n", c);
// Clean up
clReleaseMemObject(input);
clReleaseMemObject(output);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);
sleep(1); // Leopard pty bug workaround.
$ gcc hello_world_cl.c -lOpenCL -I/usr/include/CL/
8 试试PyCUDA程序
import pycuda.autoinit
import pycuda.driver as drv
import numpy
from pycuda.compiler import SourceModule
mod = SourceModule("""
__global__ void multiply_them(float *dest, float *a, float *b)
const int i = threadIdx.x;
dest[i] = a[i] * b[i];
multiply_them = mod.get_function("multiply_them")
a = numpy.random.randn(400).astype(numpy.float32)
b = numpy.random.randn(400).astype(numpy.float32)
dest = numpy.zeros_like(a)
multiply_them(
drv.Out(dest), drv.In(a), drv.In(b),
block=(400,1,1), grid=(1,1))
print dest-a*b
运行前确认显卡设备:
$ sudo apt-get install bumblebee bumblebee-nvidia
$ lspci |grep -i Nvidia
:00.0 VGA compatible controller: NVIDIA Corporation GK104M [GeForce GTX 780M] (rev ff)
以GPU形式运行pyhton:
$ optirun python
&&& import pycuda.driver as cuda
&&& import pycuda.autoinit
&&& from pycuda.compiler import SourceModule
如果都执行成功，则说明CUDA环境是安装好并可以使用的.
9 试试PyOpenCL程序
# example provided by Eilif Muller
from __future__ import division
KERNEL_CODE = """
// Thread block size
#define BLOCK_SIZE %(block_size)d
// Matrix dimensions
// (chosen as multiples of the thread block size for simplicity)
#define WA %(w_a)d // Matrix A width
#define HA %(h_a)d // Matrix A height
#define WB %(w_b)d // Matrix B width
#define HB WA
// Matrix B height
#define WC WB
// Matrix C width
#define HC HA
// Matrix C height
* Copyright
NVIDIA Corporation.
All rights reserved.
* NVIDIA Corporation and its licensors retain all intellectual property and
* proprietary rights in and to this software and related documentation.
* Any use, reproduction, disclosure, or distribution of this software
* and related documentation without an express license agreement from
* NVIDIA Corporation is strictly prohibited.
* Please refer to the applicable NVIDIA end user license agreement (EULA)
* associated with this source code for terms and conditions that govern
* your use of this NVIDIA software.
/* Matrix multiplication: C = A * B.
* Device code.
#define AS(j, i) As[i + j * BLOCK_SIZE]
#define BS(j, i) Bs[i + j * BLOCK_SIZE]
////////////////////////////////////////////////////////////////////////////////
//! Matrix multiplication on the device: C = A * B
//! WA is A's width and WB is B's width
////////////////////////////////////////////////////////////////////////////////
__kernel __attribute__((reqd_work_group_size(BLOCK_SIZE,BLOCK_SIZE,1)))
matrixMul( __global float* C, __global float* A, __global float* B)
__local float As[BLOCK_SIZE*BLOCK_SIZE];
__local float Bs[BLOCK_SIZE*BLOCK_SIZE];
// Block index
int bx = get_group_id(0);
int by = get_group_id(1);
// Thread index
int tx = get_local_id(0);
int ty = get_local_id(1);
// Index of the first sub-matrix of A processed by the block
int aBegin = WA * BLOCK_SIZE *
// Index of the last sub-matrix of A processed by the block
= aBegin + WA - 1;
// Step size used to iterate through the sub-matrices of A
= BLOCK_SIZE;
// Index of the first sub-matrix of B processed by the block
int bBegin = BLOCK_SIZE *
// Step size used to iterate through the sub-matrices of B
= BLOCK_SIZE * WB;
// Csub is used to store the element of the block sub-matrix
// that is computed by the thread
float Csub = 0.0f;
// Loop over all the sub-matrices of A and B
// required to compute the block sub-matrix
for (int a = aBegin, b = bB
a += aStep, b += bStep) {
// Load the matrices from device memory
// each thread loads
// one element of each matrix
AS(ty, tx) = A[a + WA * ty + tx];
BS(ty, tx) = B[b + WB * ty + tx];
// Synchronize to make sure the matrices are loaded
barrier(CLK_LOCAL_MEM_FENCE);
// Multiply the t
// each thread computes one element
// of the block sub-matrix
for (int k = 0; k & BLOCK_SIZE; ++k)
Csub += AS(ty, k) * BS(k, tx);
// Synchronize to make sure that the preceding
// computation is done before loading two new
// sub-matrices of A and B in the next iteration
barrier(CLK_LOCAL_MEM_FENCE);
// Write the block sub-mat
// each thread writes one element
C[get_global_id(1) * get_global_size(0) + get_global_id(0)] = C
import pyopencl as cl
from time import time
import numpy
block_size = 16
ctx = cl.create_some_context()
for dev in ctx.devices:
assert dev.local_mem_size & 0
queue = cl.CommandQueue(ctx,
properties=cl.command_queue_properties.PROFILING_ENABLE)
#queue = cl.CommandQueue(ctx)
a_height = 4096
#a_height = 1024
a_width = 2048
#a_width = 256
#b_height == a_width
b_width = a_height
elif False:
# like PyCUDA
a_height = 2516
a_width = 1472
b_height = a_width
b_width = 2144
a_width = 50*block_size
a_height = 100*block_size
b_width = 50*block_size
b_height = a_width
c_width = b_width
c_height = a_height
h_a = numpy.random.rand(a_height, a_width).astype(numpy.float32)
h_b = numpy.random.rand(b_height, b_width).astype(numpy.float32)
h_c = numpy.empty((c_height, c_width)).astype(numpy.float32)
kernel_params = {"block_size": block_size,
"w_a":a_width, "h_a":a_height, "w_b":b_width}
if "NVIDIA" in queue.device.vendor:
options = "-cl-mad-enable -cl-fast-relaxed-math"
options = ""
prg = cl.Program(ctx, KERNEL_CODE % kernel_params,
).build(options=options)
kernel = prg.matrixMul
#print prg.binaries[0]
assert a_width % block_size == 0
assert a_height % block_size == 0
assert b_width % block_size == 0
# transfer host -& device -----------------------------------------------------
mf = cl.mem_flags
t1 = time()
d_a_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=h_a)
d_b_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=h_b)
d_c_buf = cl.Buffer(ctx, mf.WRITE_ONLY, size=h_c.nbytes)
push_time = time()-t1
# warmup ----------------------------------------------------------------------
for i in range(5):
event = kernel(queue, h_c.shape[::-1], (block_size, block_size),
d_c_buf, d_a_buf, d_b_buf)
event.wait()
queue.finish()
# actual benchmark ------------------------------------------------------------
t1 = time()
count = 20
for i in range(count):
event = kernel(queue, h_c.shape[::-1], (block_size, block_size),
d_c_buf, d_a_buf, d_b_buf)
event.wait()
gpu_time = (time()-t1)/count
# transfer device -& host -----------------------------------------------------
t1 = time()
cl.enqueue_copy(queue, h_c, d_c_buf)
pull_time = time()-t1
# timing output ---------------------------------------------------------------
gpu_total_time = gpu_time+push_time+pull_time
print "GPU push+compute+pull total [s]:", gpu_total_time
print "GPU push [s]:", push_time
print "GPU pull [s]:", pull_time
print "GPU compute (host-timed) [s]:", gpu_time
print "GPU compute (event-timed) [s]: ", (event.profile.end-event.profile.start)*1e-9
gflop = h_c.size * (a_width * 2.) / (1000**3.)
gflops = gflop / gpu_time
print "GFlops/s:", gflops
# cpu comparison --------------------------------------------------------------
t1 = time()
h_c_cpu = numpy.dot(h_a,h_b)
cpu_time = time()-t1
print "GPU==CPU:",numpy.allclose(h_c, h_c_cpu)
print "CPU time (s)", cpu_time
print "GPU speedup (with transfer): ", cpu_time/gpu_total_time
print "GPU speedup (without transfer): ", cpu_time/gpu_time
在Mac上运行结果:
Choose device(s):
[0] &pyopencl.Device 'Intel(R) Core(TM) i5-4258U CPU @ 2.40GHz' on 'Apple' at 0xffffffff&
[1] &pyopencl.Device 'Iris' on 'Apple' at 0x1024500&
Choice, comma-separated [0]:1
Set the environment variable PYOPENCL_CTX='1' to avoid being asked again.
GPU push+compute+pull total [s]: 0.1
GPU push [s]: 0.076
GPU pull [s]: 0.66
GPU compute (host-timed) [s]: 0.4
GPU compute (event-timed) [s]:
GFlops/s: 46.
GPU==CPU: True
CPU time (s) 0.9
GPU speedup (with transfer):
GPU speedup (without transfer):
被 Ubuntu的Unity冻结问题 搞的身心疲惫，浪费大量时间。学习GPU开发本不在今年的计划之内，就先开个头，我还会回来的！
作者简介：
朱春来(Leslie Zhu)，金融工程师，毕业于西安电子科技大学, 喜欢历史，喜欢编程. 日常在GNU/Linux环境下进行C/C++、Python开发，对Common Lisp、Node.js、金融等感兴趣。可以通过邮箱()联系他，或者直接在他的个人主页上.
士不可以不弘毅，任重而道远！
原文地址：, 感谢原作者分享。
您可能感兴趣的代码> GLTools(修改手机和平板GPU信息)1.08
分辨率:320x480,480x854,480x800,960x540,0x1080
抱歉，已经删除，无法下载
《GLTools》是一款类似3D神器的应用，能修改手机和平板的GPU信息，从而去玩一些某种处理器的专属游戏。安装需要Root权限，如果没有ROOT权限，又想获得ROOT权限：安装后有可能导致所有游戏黑屏或者系统崩溃，并需要刷机恢复，仅推荐动手能力强的玩家使用。
0 && image.height>0){if(image.height>=300){this.height=300;this.width=image.width*300/image.}}" />
0 && image.height>0){if(image.height>=300){this.height=300;this.width=image.width*300/image.}}" />
相关标签：
安卓优化大师4.0.0正式更名为【baidu手机卫兵】它是Andr....
我曾经未进汉化组之前汉化过免费版，这次汉化的是已付费专业版，自己通....
奇门遁甲是陈旧的法术，是三式之一。前期首要用于军事布阵排兵，后应用....
NotifierPro Plus（信息告诉增强版）是一款专业的音讯....
电源控件 Power Toggles 是款Android4.0个性....
360手机助手最新版集合了手机系统综合管理,海量应用轻松下载,升级....
360手机助手集合了手机系统综合管理,海量应用轻松下载,升级手机应....
免费软件，游戏下载，精选安卓手机和平板优秀软件供下载，安卓软件园W....
注意:本软件是在PC(电脑)上安装运行的哦.手机软件下载和安装服务....
提示：本软件下载以后是在电脑上(PC)上面运行的。
安卓软件园联....手机签到经验翻倍！快来扫一扫！
【已解决！】楼主已经疯了！这问题叫啥？显卡丢驱动？大神们进来看看啊
923浏览 / 22回复
首先上配置，这机器也算是刚攒的吧，也就2个月
显卡是inno3d gtx660 冰龙2G
然后问题就来了
这是在玩英雄无敌6的时候出现的，先卡一下，或者是黑一下屏，然后就无法继续运行了（），只能任务管理器了。
之前在鬼泣5（帧数降至10左右），无主之地2（同鬼泣），极品17（同英雄无敌6）中都出现了类似的问题，括号内为具体表现。
游戏玩的很顺畅，全特效下帧数也很不错，但就是出现这样的问题。
网上的方法都试过了，换了N多，就是不管事啊，目前的驱动是正式版的，就是whql的。
求各位大神指点迷津啊！！！！
————————————————————————我是分割线——————————————————————————————
方法很多，但是只有这个对我来说管用。就是用到了nvidia inspector这个软件，大家可以百度下载。设置如下：
就是把两个频率都调低了100，当然你也可以试试先调个60-80。
具体办法也是在坛子上找的哈，具体是哪个管友说的我一高兴就没节操的忘记了= =总之非常感谢那位管！
最后还想问问，这样设置有什么不妥吗？本人真小白一个
什么系统？最近更改系统设置没？
恭喜你，显卡坏了，我的显卡已经送修，刚开始也是你这样的情况，有时候还能自动恢复，到后面直接黑屏死机
对 第1楼 meng5400 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝win7 64位的，系统没去动
对 第2楼 唯所欲为 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝别啊，真这样？显卡是inno3d gtx660 冰龙
对 第4楼 tle31172 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝哥们，握手，我的卡是冰龙560TI，已送保半个月。
对 第4楼 tle31172 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝你还是先用排除法看看到底是硬件问题还是软件问题，更换下内存或者CPU看看
对 楼主 tle31172 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝换一块试试
对 第6楼 唯所欲为 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝我在试调低显卡主频和显存频率的方法，一会给你结果啊
对 楼主 tle31172 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝无解，跟显卡 显卡驱动 win7 三者都有关系，不只是N卡 A卡也这样你可以上百度搜索下
7850CF dirt3驱动停止响应
对 第10楼 UzumakiNaruto 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝看来换卡才是王道么。。我现在把显存和显卡频率调低了80，情况有点好转
重新下载个系统装上，我是这样解决的
对 楼主 tle31172 说：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝游戏把显卡蹦了。。就是这样。。
不是自动恢复了么。。。放在以前连恢复都不让的。。
貌似我的显卡微星N650TI也有这个问题，驱动也是314.07.我怀疑是驱动问题，原来用的310.90就没这个问题。
换内存或者显卡试试
保内的话去看看
体质不行~还是早点拿卡去换吧~这种问题时间长了各种黑屏死机的~
支持键盘翻页 ( 左右 )&
用户名/注册邮箱/注册手机号
其他第三方号登录